Reproducibility

Reproducible analysis means you can re-run exactly what you did — on the same data or on new data — and get the same result, and that someone else can read and verify your steps. ChakataStat is built around this: every menu action is also a command, and the commands form a stream you can read, edit, save, replay, batch and export.

The syntax console (`.cks`)

Open it with View → Syntax (Ctrl+4). It shows your session as an editable ChakataStat syntax script — the .cks language. Every analysis, chart and journalable transform you run from the menus appends a line here automatically:

descriptives variables=[Age, BMI, SystolicBP]
correlate variables=[BMI, SystolicBP], method=pearson
compute target=BMI_cat, expr="IF(BMI >= 30, 1, 0)"
histogram variable=BMI

The grammar is small and readable: toolname arg=value, arg=[a, b], arg="text", with # for comments.

Running and editing

Run all / Run selection parse the script and dispatch each command into the Output log. Replaying does not re-record the commands.
Parse errors and failed commands are reported in a status panel as data — a bad line never crashes the run.
The console and the GUI are two views of one stream: edit the text and re-run, or keep clicking menus and watch the script grow.

Saving and opening scripts

Save the script as an .cks file and open it later (or hand it to a colleague). The session also remembers the script between launches.

The command palette

View → Command Palette… (Ctrl+Shift+P) is a fast, keyboard-driven launcher: start typing the name of any analysis, chart, transform, file or view command and run it without hunting through menus. It is built from the same tool catalog the menus, the AI and MCP use, so it can never drift out of sync.

Headless batch mode (`--run`)

For pipelines, CI and reproducible research, run a script against a dataset with no window:

ChakataStat --run script.cks data.ckd --out report.html

This loads the dataset, runs every command in the .cks script through the same engine, and writes the output log as a report. The output format follows the --out extension — HTML, Markdown or LaTeX. It shares the headless engine bootstrap with the MCP mode, so batch results match what the GUI produces.

Exporting the output log

File → Export Output… (or the Output view's Export… button) writes your whole results log to HTML, Markdown or LaTeX — the format chosen from the file extension. Tables are escaped per format and charts are rendered as their geometry. For a single result, right-click its card and choose Export as CSV… to drop it straight into a spreadsheet (or use copy-to-clipboard).

Exporting a session as Python

Export as Python… (from the syntax console) renders your recorded session as a runnable Python script for the ChakataStat Python client. The client (the ChakataStat Python package) drives a headless engine over MCP and exposes every analysis as a method:

import ChakataStat as ig

ds = ig.open("health_study.ckd")     # spawns the headless engine
ds.descriptives(["Age", "BMI", "SystolicBP"])
ds.regression("SystolicBP", ["Age", "BMI"])

for col in ds.numeric_vars():         # real Python: loops, logic
    ds.frequencies([col])

df = ds.to_polars()                   # escape hatch into the Polars ecosystem

This gives you full programmatic control and the whole Python data ecosystem (polars, numpy, scipy, statsmodels) without ChakataStat embedding any of it — Python is an external client over the same seam the AI and MCP use, so the single engine and the errors-as-data discipline are preserved.

Why this matters

The flat command stream is the one canonical record of an analysis. Because the GUI both emits it and can reconstruct itself from it, "what I clicked" and "what I can replay" are the same thing — the foundation that the batch mode, the command palette, user-defined tools and the Python export all build on.