TS Convert From Qlik

Qlik Sense → ThoughtSpot

Converts a Qlik Sense app into ThoughtSpot objects through the ts qlik CLI: parse the app (offline .qvf or a Qlik Engine artifacts directory) → build Table + Model TML → build a tabbed Liveboard (one tab per Qlik sheet) → validate and import. Anything it cannot faithfully translate — Set Analysis with current-selection state, Qlik variables, functions with no ThoughtSpot equivalent — is flagged NEEDS REVIEW in the migration report, never silently downgraded to a wrong-but-valid substitute.

Ask one question at a time for dependent decisions (where the next depends on the answer); batch independent questions into a single prompt to keep the migration fast.

References

Prerequisites

• ThoughtSpot profile configured — run /ts-profile-thoughtspot if not.
• ts CLI installed: pip install -e tools/ts-cli. For the live modes (below), also install the Qlik extra: pip install -e 'tools/ts-cli[qlik]' (adds websocket-client).
• A Qlik source, one of four --mode values:
  • offline (default) — an offline .qvf app file. Recovers what it can (tables, columns, master measures, sheets) and flags what it cannot; no live Qlik connection.
  • engine-artifacts — a directory exported by the Qlik Engine API.
  • qlik-cloud — pulls exact definitions live from a Qlik Cloud tenant (the foolproof, SOURCE-provenance path — no guessing). Needs --tenant <url> --app-id <guid|name> and an API key (via --api-key or, preferred, the QLIK_API_KEY env var).
  • engine — a running Qlik Engine over websocket (--engine <wss-url> --app-id <guid>, optional repeatable --header k=v). Credentials are never entered in this conversation — the user sets QLIK_API_KEY (or passes --api-key) in their own terminal; the value is never echoed or written to a file.
• The source tables already exist in a warehouse and a ThoughtSpot connection exposes them. This skill creates ThoughtSpot logical objects (Table, Model, Liveboard) over existing physical tables; it does not load data. For a demo, ts load can provision synthetic tables.

Workflow

Step 0 — Parse

ts qlik parse <app.qvf> --output /tmp/qlik_inv.json
# or, from a Qlik Engine artifacts export:
ts qlik parse <artifacts-dir> --mode engine-artifacts --output /tmp/qlik_inv.json
# or, live from Qlik Cloud (foolproof path — needs QLIK_API_KEY set in the shell):
ts qlik parse --mode qlik-cloud --tenant <tenant-url> --app-id <guid|name> --output /tmp/qlik_inv.json
# or, live from a Qlik Engine websocket:
ts qlik parse --mode engine --engine <wss-url> --app-id <guid> --output /tmp/qlik_inv.json

build-model and build-liveboard accept the same --mode and connection flags, so the whole chain can run against any source. The live modes give SOURCE provenance (exact definitions); offline/engine-artifacts give best-effort extraction that flags gaps. Emits tables, columns, master measures, master dimensions, sheets and charts, plus counts. Read it; note any warnings (the parser flags what it could not read rather than guessing). An opaque .qvf degrades to warnings and an empty-but-valid inventory — it never crashes.

Step 1 — Build the model

ts qlik build-model <app.qvf> --connection "<TS connection>" \
  --db <DATABASE> --schema <SCHEMA> --model-name "<Model name>" --output out/ \
  [--overrides overrides.json] [--types wh_types.json] [--mode offline|engine-artifacts]

Emits Table TML(s) + Model TML + mapping.json. Master-measure expressions become formulas ([formula_<name>] id-references, so they import in a single pass). Column data types come from the warehouse type map (--types) when supplied, else are inferred from Qlik field types. Set Analysis using current-selection ($) context, Qlik variables, and functions with no ThoughtSpot equivalent are flagged NEEDS REVIEW — never faked. Read mapping.json.

Step 2 — Validate & import the model

Lint, then import the tables + model, VALIDATE_ONLY first, then real:

ts tml lint out/*.tml
ts tml import out/*.table.tml out/*.model.tml --profile <name> --policy VALIDATE_ONLY
ts tml import out/*.table.tml out/*.model.tml --profile <name>

If the engine rejects a formula, drop it (and any column that depends on it) and re-import — what lands is guaranteed to work, and the report records what was pruned.

Step 3 — Build & import the liveboard

ts qlik build-liveboard <app.qvf> --model-name "<Model name>" --output out/ \
  [--model-fqn <model-guid>] [--report-name "<Liveboard name>"]
ts tml lint out/*.liveboard.tml                          # pre-import: flags any blank chart tile
ts tml import out/*.liveboard.tml --profile <name>
ts tml verify-render <liveboard-guid> --profile <name>    # post-import gate; exit 1 = broken board

Why the lint line is here and not in Step 2. Step 2 lints out/*.tml before the liveboard exists, so it never sees the tile. The chart_tiles_missing_axis rule (a chart type that needs an axis carrying neither axis_configs nor custom_chart_config imports cleanly and renders blank) therefore had no gate on this path at all — and this was the one converter whose builder violated it, so its boards shipped empty (audit finding 17.3; emitter fixed in the same change). Each Qlik sheet becomes a Liveboard tab; each chart becomes an embedded Answer whose search query is built from the chart's dimensions and measures. Chart types with no ThoughtSpot equivalent default to a table and are flagged.

Step 4 — The hard tail

Set Analysis current-selection state and Qlik variables have no 1:1 ThoughtSpot path — recreate them as Model formulas, parameters, or RLS as appropriate (see the coverage matrix). For an expressible flagged measure, ts spotter answer can draft it from plain English; verify the numbers on the cluster before adopting — never auto-adopt a Spotter answer.

Step 5 — Migration report

mapping.json accounts for every table, measure, and chart with a status (Migrated / Approximated / NEEDS REVIEW / Skipped). Render it into a migration_report.md following references/migration-report-format.md — keep the section order and the exact status vocabulary — and hand that to the user as the deliverable. Never silently drop a source object: every one appears in a table with a status.

Changelog