jinflow CLI Cheat Sheet

Concepts

Term	What it is
Pack	Domain-specific analytics kit (e.g. Millesime for winemaking, Alptrack for ski resorts)
Tenant	One client / site. Pack-qualified: `millesime.domaine_zufferey`
KLS	Knowledge Store — the DuckDB file you build and explore
AFS	Artifact Store — the analytical framework (signals, theses, dbt, contracts)
Snapshot	Immutable, frozen copy of a KLS
DLZ	Data Landing Zone — where raw data arrives from the source system
Live Root	Where tenant instances live on disk (`~/.jinflow/live/` by default)
Deploy Root	Where the application package lives (CLI + Explorer binary)
Pre-Make	Preparation phase: extract source data, publish SIS content to AFS, commit. Has side effects
Make (pure function)	Build phase: AFS in → KLS out. No SIS mutation, no external fetches. Pure function
Extraction Contract	`pipeline.yml` at the tenant AFS root: lists every extract file with SHA-256 pin and expected schema
Operating Mode	One of five deployment topologies: Local, Proxy (P2P2P), Cloud, Semi-Cloud, Make-as-a-Service
Supply-Org	Pricing grain dimension (SAP Plant). Canonical values in nuMetrix: `PHA`, `LOG`. Pricing key is `(material, supply_org)`

Installation

macOS

Download the release package, extract it, and add to your PATH:

export PATH="$HOME/jinflow:$PATH"    # add to your shell profile
jinflow version                       # verify installation

Windows

Download the latest release ZIP, extract it. Run via jinflow.bat or add the folder to your PATH.

Linux

Download the latest release tar.gz, extract it, add to PATH.

First-time config

jinflow us --live-root ~/jinflow-data        # where tenant data lives
jinflow us --api-key sk-ant-...              # Claude API key (for AI features)
jinflow us millesime.domaine_zufferey            # set default tenant

Commands

`jinflow us` — Configuration

jinflow us                                # show current config with provenance
jinflow us pack.tenant                    # set default tenant
jinflow us --live-root /path              # set data directory
jinflow us --api-key sk-ant-...           # set Claude API key
jinflow us --model claude-opus-4-6        # set AI model for evolve

`jinflow config` — Configuration inspector

jinflow config                                # show all resolved configuration
jinflow config display.precision              # show specific key with provenance
jinflow config --diff                         # show tenant overrides vs pack defaults
jinflow config millesime.domaine_zufferey     # specific tenant

`jinflow ls` — List tenants

jinflow ls                                # list all packs + tenants (KLS size, source system, CSV count)
jinflow ls --snapshots                    # include snapshot details for all tenants
jinflow ls --snapshots my_tenant           # snapshots for one tenant

`jinflow pick` — Interactive tenant picker

jinflow pick                              # list tenants, pick one, set as default

`jinflow init` — Create a tenant

jinflow init --pack millesime --tenant my_org --source-system opale
jinflow init --pack millesime --tenant my_org --dlz /path/to/dlz           # auto-detect source system
jinflow init --pack millesime --tenant my_org --display-name "My Organization"
jinflow init --pack millesime --tenant my_org --engine-repo /path           # custom engine repo

`jinflow clone` — Copy a tenant

jinflow clone millesime.domaine_zufferey --name sandbox         # → domaine_zufferey_sandbox
jinflow clone millesime.domaine_zufferey --name sandbox --display-name "Sandbox"
jinflow clone millesime.domaine_zufferey --name sandbox --no-share-dlz  # independent DLZ copy

`jinflow afs update` — Sync tenant AFS with pack

jinflow afs update                            # dry-run (show what would change)
jinflow afs update --do-it                    # apply updates from domain pack
jinflow afs update millesime.domaine_zufferey               # specific tenant

`jinflow afs reset` — Hard-reset tenant AFS

jinflow afs reset                             # reset current tenant AFS to match pack exactly
jinflow afs reset millesime.domaine_zufferey                # specific tenant

`jinflow afs remote` — Manage git remote

jinflow afs remote                            # show current remote URL
jinflow afs remote https://github.com/org/afs.git  # set remote URL

`jinflow afs status` — AFS git status

jinflow afs status                            # show branch, tags, dirty files
jinflow afs status millesime.domaine_zufferey               # specific tenant

`jinflow afs log` — Build logbook

jinflow afs log                               # show commit history / build logbook

`jinflow afs pull` — Pull from remote

jinflow afs pull                              # fast-forward pull from remote

`jinflow afs push` — Commit and push

jinflow afs push                              # commit changes and push to remote
jinflow afs push -m "Updated signals"          # with commit message

`jinflow afs pp` — Pull then push

jinflow afs pp                                # pull then push in one command

`jinflow pre-make` — Preparation phase

jinflow pre-make                          # extract + publish SIS content (default tenant)
jinflow pre-make millesime.domaine_zufferey              # specific tenant
jinflow pre-make --notes-only             # just publish SIS content (notes, bookmarks)
jinflow pre-make --extract-only           # just extract sources

Pre-make is the side-effecting phase: extract source data from the DLZ, fetch notes and bookmarks from the SIS, write both to the AFS, commit to git. After pre-make, make runs as a pure function. See the Make Guide.

`jinflow extract` — Convert XLSX to CSV (standalone)

jinflow extract                           # extract for default tenant
jinflow extract --contract                # render the full extraction contract (pipeline.yml)
jinflow extract --check                   # verify all declared SHA-256 hashes without running extraction
jinflow extract --list                    # machine-readable: id, path, status, last hash
jinflow extract millesime.domaine_zufferey              # specific tenant
jinflow extract --continue-on-error       # don't fail-fast
jinflow extract --quiet                   # suppress subprocess output

jin extract sees extraction (inspect, verify). jin make does extraction (runs it as Phase 0). See the Extraction Guide for the trust-boundary model.

`jinflow generate` — Synthetic data

jinflow generate                          # generate synthetic data for default tenant
jinflow generate millesime.domaine_zufferey             # specific tenant

`jinflow make` — Build

jinflow make                              # build default tenant
jinflow make millesime.domaine_zufferey   # build specific tenant
jinflow make millesime                    # build all tenants in pack (wildcard)
jinflow make --afs /path/to/afs           # explicit AFS path
jinflow make --clean                      # drop and rebuild KLS from scratch
jinflow make --extract                    # extract XLSX → CSV in DLZ, then update-raw, then build
jinflow make --sync                 # copy CSVs from DLZ to raw/ before building
jinflow make --snapshot                   # freeze KLS after build (auto-tag: YYYYMMDD-HHMM)
jinflow make --snapshot post-audit        # freeze with named tag
jinflow make --skip-enrich                # skip CSV enrichment step
jinflow make --skip-validate              # skip CSV schema validation step
jinflow make --no-deps                    # skip dbt deps install
jinflow make --continue-on-error          # collect all errors instead of fail-fast
jinflow make --quiet                      # suppress subprocess output

Build pipeline phases:

Enrich CSVs (add lineage columns)
Validate CSV schemas
Compile all instruments (signals, theses, verdicts, SMEbits, BitBundles, lineage, entities, reports)
dbt build: core (bronze → silver → gold) → analytics (signals, theses, verdicts, SMEbits) → reports → lineage
Post-build: pipeline graph, audit reports (PDF), extract PDFs from KLS

After build, PDF reports are extracted from the KLS audit_reports table into kls/reports/{tenant_id}/*.pdf.

`jinflow explore` — Web UI

jinflow explore                           # default tenant, port 4000
jinflow explore szo                       # specific tenant
jinflow explore --afs /path/to/afs        # explicit AFS path
jinflow explore --db /path/to/kls.duckdb  # explicit KLS path
jinflow explore --snapshot post-audit     # open a specific snapshot
jinflow explore --port 3000               # custom port
jinflow explore --docker                  # run Explorer in Docker
jinflow explore --no-open                 # don't open browser automatically

`jinflow snapshot` — Freeze current KLS

jinflow snapshot                          # auto-tag: YYYYMMDD-HHMM
jinflow snapshot post-audit               # named tag
jinflow snapshot millesime.domaine_zufferey             # specific tenant

`jinflow status` — AFS status

jinflow status                            # current AFS summary
jinflow status --afs /path/to/afs         # specific AFS

`jinflow scripts` — Script resolution

jinflow scripts                           # show which script wins at each layer
jinflow scripts millesime.domaine_zufferey              # specific tenant

`jinflow evolve` — AI exploration

jinflow evolve                            # interactive REPL (AI + SQL)
jinflow evolve millesime.domaine_zufferey  # specific tenant
jinflow evolve --afs /path/to/afs         # explicit AFS path
jinflow evolve --db /path/to/kls.duckdb   # explicit KLS path
jinflow evolve --model claude-opus-4-6    # choose AI model
jinflow evolve --no-ai                    # SQL-only mode (no API calls)

`jinflow sources` — Source file inventory

jinflow sources                           # show CSVs, schemas, row counts, DLZ lineage
jinflow sources millesime.domaine_zufferey # specific tenant

`jinflow stat` — KLS statistics

jinflow stat                              # gold layer counts, analytics pyramid, health checks
jinflow stat millesime.domaine_zufferey                 # specific tenant

`jinflow purge` — Slim down KLS

jinflow purge millesime.domaine_zufferey          # dry-run (show stats)
jinflow purge millesime.domaine_zufferey --do-it  # drop bronze + silver tables

`jinflow notebook-pdf` — Export notebook as PDF

jinflow notebook-pdf nb_io_article_reconciliation           # export to PDF
jinflow notebook-pdf nb_io_article_reconciliation --lang de # German version
jinflow notebook-pdf nb_io_article_reconciliation -o out.pdf

`jinflow help` — Detailed help

jinflow help                              # list all commands
jinflow help make                         # detailed help for a command

`jinflow release-notes` — Generate release notes

jinflow release-notes                     # generate RELEASE_NOTES.md from git

`jinflow pack` — Pack operations

jinflow pack ls                           # list packs, artifacts, tenant sync status
jinflow pack ls --sync                    # include sync status for all tenants
jinflow pack clone millesime               # clone a domain pack from GitHub
jinflow pack clone millesime --https       # clone via HTTPS instead of SSH

`jinflow ship` — Build, sync, and refresh

jinflow ship                              # dry run: see what would happen
jinflow ship --do-it                      # current tenant → sync → refresh
jinflow ship --all --do-it                # all tenants → sync → refresh
jinflow ship --all --do-it --clean        # clean build all → sync → refresh
jinflow ship millesime --do-it            # one pack only

`jinflow cloud` — R2 cloud operations

jinflow cloud ls                          # list KLS files and R2 sync status
jinflow cloud ls --local-only             # only show local files
jinflow cloud sync --do-it                # upload KLS files to R2
jinflow cloud sync --do-it --prune        # upload + delete remote files not in local
jinflow cloud blacklist millesime.domaine_zufferey      # exclude tenant from sync
jinflow cloud blacklist millesime.domaine_zufferey --remove  # re-include tenant

`jinflow instance` — Manage deployed instances

jinflow instance ls                                    # list registered instances
jinflow instance add demo https://this-is.jinflow.io   # register an instance
jinflow instance remove demo                           # remove an instance
jinflow instance refresh demo                          # tell instance to re-download from R2
jinflow instance refresh --all                         # refresh all instances
jinflow instance refresh demo --scope pack --pack millesime  # refresh specific pack

`jinflow version` — Version info

jinflow version                           # show version + release notes

Evolve REPL

Two modes: ai.less (SQL + commands) and with.ai (Claude-powered natural language).

Command	Description
`SELECT ...`	Run any SQL (also INSERT, CREATE, any valid DuckDB statement)
`/tenants`	List tenants in the KLS
`/schema <name>`	Describe a DuckDB schema (e.g. `/schema domaine_zufferey`)
`/probes`	List signals (also `/hypotheses`, `/diagnoses`, `/smebits`)
`/read <type> <id>`	Read artifact YAML (e.g. `/read probes probe_revenue_leakage`)
`/write <type> <id> <yaml>`	Write artifact to AFS (e.g. `/write probes probe_test '{...}'`)
`/delete <type> <id>`	Delete artifact from AFS
`/explain <Type> <id> [tenant]`	Entity dossier (e.g. `/explain Case CASE_0001 my_tenant`)
`/make [flags]`	Rebuild KLS without leaving the REPL (resets AI context)
`/ai`	Toggle AI mode on/off
`/help`	Show help
`exit`	Quit

In with.ai mode, type natural language — Claude queries DuckDB, reads/writes artifacts, and explains entities automatically.

Workflow

The core loop

  jinflow make        Build the KLS
       ↓
  jinflow explore     Browse findings in the web UI
       ↓
  jinflow evolve      Ask questions, discover patterns, add signals
       ↓
  /make               Rebuild from within evolve
       ↓
  Back to explore...

Onboarding a new tenant

jinflow init --pack millesime --tenant new_org --source-system opale
# place XLSX exports in DLZ: {dlz}/new_org/opale/xslx/
# or place CSVs directly:    {dlz}/new_org/opale/csv/
jinflow make millesime.new_org --extract --clean   # full pipeline
jinflow explore millesime.new_org

Snapshotting

jinflow make                     # iterate...
jinflow make --snapshot          # freeze when happy
jinflow explore --snapshot 20260311-1430   # revisit anytime

Syncing with the pack

jinflow afs update                   # dry-run — see what changed in the pack
jinflow afs update --do-it           # apply changes
jinflow make                     # rebuild with updated instruments

Data Flow

DLZ (Data Landing Zone)
  └── extract (XLSX → CSV)
       └── raw/ (immutable source CSVs)
            └── enrich → build/csv/ (enriched CSVs)
                 └── dbt build → KLS (DuckDB)
                      └── audit reports → kls/reports/*.pdf

Tenant Instance Layout

~/.jinflow/live/
  {pack}/
    {tenant}/
      afs/                          ← analytical framework (git repo)
        signals/, theses/, ...
        dbt/{pack}/
        reports/                    ← report YAML definitions
        jinflow.yml                 ← pack manifest
      raw/                          ← immutable source CSVs
        {source_system}/csv/
      build/                        ← intermediaries
        csv/                        ← enriched CSVs that dbt reads
      kls/                          ← KLS files
        {pack}_{tenant}_kls.duckdb        ← working copy
        post-audit.duckdb             ← named snapshot
        reports/                      ← PDF reports extracted from KLS
          {tenant_id}/
            report_executive_summary.pdf
            report_data_quality.pdf

Reports

Reports are declaratively defined (reports/*.yaml), compiled to dbt SQL by reportcompile.py, built as dbt models (tag:report), then rendered to PDF by auditreport.py (requires weasyprint). The PDFs are stored inside the KLS in an audit_reports table and extracted to kls/reports/{tenant_id}/*.pdf after every build.

Reports are also browsable in the Explorer at /{tenant}/reports.

Analytics Pyramid

                ┌─────────────┐
                │  Verdicts  │  WHY is it happening?
                ├─────────────┤
                │ Theses  │  WHAT is happening?
                ├─────────────┤
                │   Signals    │  What does the DATA show?
                ├─────────────┤
                │ Perspectives │  Entity-level health scores
                ├─────────────┤
                │    Gold     │  Product contract
                ├─────────────┤
                │   Silver    │  Domain truth
                ├─────────────┤
                │   Bronze    │  Structural ingestion
                └─────────────┘

    ┌─────────────┐
    │  SMEbits    │  Expert knowledge (free-floating)
    ├─────────────┤
    │ BitBundles  │  Curated narratives
    └─────────────┘

Environment Variables

Variable	Purpose
`JINFLOW_LIVE`	Override live root (data directory)
`JINFLOW_TENANT`	Override default tenant
`JINFLOW_DB_PATH`	Explicit KLS DuckDB path
`JINFLOW_AFS_ROOT`	AFS root (for Explorer)
`JINFLOW_TENANTS_DIR`	Tenants directory (for Explorer)
`JINFLOW_SYSTEM_DB_PATH`	System DB path (optional, operational state)
`JINFLOW_DEPLOY_ROOT`	Deploy root for app package
`ANTHROPIC_API_KEY`	Claude API key (for evolve)

jinflow is a jazzisnow product

v0.45.1 · built 2026-04-17 08:14 UTC 

jinflow CLI Cheat Sheet

Concepts

Installation

macOS

Windows

Linux

First-time config

Commands

jinflow us — Configuration

jinflow config — Configuration inspector

jinflow ls — List tenants

jinflow pick — Interactive tenant picker

jinflow init — Create a tenant

jinflow clone — Copy a tenant

jinflow afs update — Sync tenant AFS with pack

jinflow afs reset — Hard-reset tenant AFS

jinflow afs remote — Manage git remote

jinflow afs status — AFS git status

jinflow afs log — Build logbook

jinflow afs pull — Pull from remote

jinflow afs push — Commit and push

jinflow afs pp — Pull then push

jinflow pre-make — Preparation phase

jinflow extract — Convert XLSX to CSV (standalone)

jinflow generate — Synthetic data

jinflow make — Build

jinflow explore — Web UI

jinflow snapshot — Freeze current KLS

jinflow status — AFS status

jinflow scripts — Script resolution

jinflow evolve — AI exploration

jinflow sources — Source file inventory

jinflow stat — KLS statistics

jinflow purge — Slim down KLS

jinflow notebook-pdf — Export notebook as PDF

jinflow help — Detailed help

jinflow release-notes — Generate release notes

jinflow pack — Pack operations

jinflow ship — Build, sync, and refresh

jinflow cloud — R2 cloud operations

jinflow instance — Manage deployed instances

jinflow version — Version info