Metadata-Version: 2.4
Name: shivelinc
Version: 3.32.3
Summary: φ-lang v6 + φC engine + CR38 notebook renderer (shivelinc fork): chessboard-coordinate handwriting notebooks (.ram/.gθ), Rot24 fold geometry, point-blob codec, street/map rendering, shivelinc Board/HyperBoard binding
Author: Shivansh Rao Mavidanam
License: MIT
Keywords: phi-lang,chess,capability,engine,philang,cr38,notebook,handwriting,shivelinc
Classifier: Programming Language :: Python :: 3
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: MacOS
Classifier: Operating System :: POSIX :: Linux
Classifier: Topic :: Software Development :: Libraries
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Requires-Dist: python-chess>=1.999
Requires-Dist: numpy>=1.20
Provides-Extra: shape
Requires-Dist: matplotlib>=3.5; extra == "shape"
Requires-Dist: numpy>=1.20; extra == "shape"
Provides-Extra: cr38-render
Requires-Dist: Pillow>=9.0; extra == "cr38-render"

# shivelinc

φ-lang v6 + φC engine + CR38 notebook renderer — Shiv's own engine library.
C-first base, 42-language access, inventory-first organization.

## The three-layer doctrine

| Layer | Role | Grows by |
|---|---|---|
| `inventory/` | **Primitive blocks** you build apps *from* (any language: C, Python, AppleScript, SQL, Fortran, COBOL…) | ~1 genuinely-new block per new app |
| `apps/` | **Creations** — thin compositions of inventory blocks (1 C orchestrator + manifest + SKILL.md) | new app ≈ 1 C script + config |
| `shivelinc/` (engine) | **The substrate**: 111 modules, dictionary, 42 grammars, 40 language builders, skill store, corpus | ingest/corpus growth |

Rules that keep the model honest:
1. **C first, all languages reachable** — C is the orchestrator/base layer; the 42
   grammar profiles make every other language a *projection* of the same
   substrate, never a separate stack.
2. **Knowledge data lives in the engine** (dictionaries, grammars, skill store);
   **app data lives at runtime** under `apps/<name>/data` + `www/` (gitignored,
   regenerated); **building blocks live in inventory**.
3. **Growth law**: first app of a *class* pays all N blocks; later same-class
   apps pay ~1 (source glue); a new class is the honest δ jump. Track
   `mean δ per app` → falls toward 1; critical mass = where it stops falling.
   Visualize live: `apps/growth-lab` (localhost 8766) — Fortran curve fit +
   COBOL packing on real repo state.
4. **Tensors index, they don't operate** — every stamped file carries the
   slot vector (`t` + 11 tensors + `r_`); atoms give blocks code-addresses;
   search routes: need-words → atoms → blocks. That is metadata for routing.

## Layout

```
shivelinc/
├── inventory/            primitives (manifest.json is the ledger)
│   ├── applescript/  python/  sql/  c/  fortran/  cobol/
├── apps/
│   ├── apple-music-library-relay/   collection relay (export→SQL→dashboard→serve)
│   └── growth-lab/                  growth-model dashboard (8766)
├── shivelinc/           python package (engine) — 111 modules
│   ├── data/  grammars/  skills/  classes/  libraries/  cr38/  brain/  engine/
├── pyproject.toml · README.md · .gitignore
```

## Baseline history

- **2026-09-02** — fork of chlang 3.31.3 → shivelinc (full rename; corpus
  byte-identical; numpy moved to base deps). Private GitHub
  `shivtcdfinance/shivelinc`; PyPI `shivelinc`.
- **3.31.4** — first converted skill corpus: apple-music-library-relay
  (store 413→414).
- **3.31.5** — inventory-first restructure (`inventory/` + `apps/`),
  growth-lab app (Fortran/COBOL compute cores), docstring corrections,
  store 414→415.

## Install (dev)

```bash
cd ~/Hermes/v3/v4/software/shivelinc
python3.11 -m venv .venv
.venv/bin/pip install -e .
.venv/bin/python -c "import shivelinc; print(shivelinc.__version__)"
```

## Smoke test

```python
import shivelinc
print(shivelinc.__version__)                 # 3.31.5
shivelinc.skill_get("apple-music-library-relay")   # registered skill
from shivelinc.phi_skill import skill_count  # 415
```

## Building a new app (the ~1-script delta)

1. `mkdir apps/<name>` + `app.manifest.json` listing inventory blocks you reuse.
2. Write ONE orchestrator `.c` (stamped, raman_header_spec) — commands that
   call inventory blocks with `SHIVELINC_APP_ROOT`/`SHIVELINC_INVENTORY` env.
3. Add the source-glue block to `inventory/` (the genuinely-new piece).
4. Register in the skill store; update `inventory/manifest.json`.

Conventions inherited from chlang: public symbols append-only; additions
recorded in `version_chain.py`; `pip install --upgrade` wipes site-packages
edits (always work from this repo).
