CLI

The axint binary covers ten big jobs:

scaffold and compile Apple-native surfaces
validate Swift and mechanical Apple-facing issues
repair existing Apple app bugs with project context
create privacy-safe feedback packets for repeated Axint gaps
connect AI tools through MCP and repair packets
upgrade the agent toolchain without losing the current Codex or Claude thread
wire the optional Xcode workflow
coordinate multiple local agents through one project brain
build a local project memory index from context, proof, repairs, and feedback
report source-free adoption signal so the Axint team can see which install paths actually work

`axint init [dir]`

Scaffold a new Axint project, or initialize Axint inside an existing Apple/Xcode project.

axint init my-intents              # default template (send-message)
axint init my-intents --template log-workout
axint init --apple-project /path/to/MyApp --agent codex

Creates:

package.json (pinning @axint/compiler at the current version)
tsconfig.json
intents/ with the starter template
ios/Intents/ (output target)
.vscode/mcp.json (pre-wired for Claude Code / Cursor / Windsurf)
.gitignore
README.md

For existing Apple projects, --apple-project writes the project start pack, installs the local multi-agent brain, and prints the next axint agent advice and axint run commands for the selected host lane. Refuses to scaffold in a non-empty directory unless --force is passed.

`axint create [dir]`

Create a first-run Axint app through the same scaffolder exposed by create-axint-app. Use this when a developer wants the shortest possible entrypoint from a fresh terminal into a compilable Axint project.

axint create my-apple-agent
npx create-axint-app my-apple-agent
npx -y -p @axint/compiler create-axint-app my-apple-agent --template send-message

create is intentionally a friendlier alias around the project bootstrap path: it pins the current compiler, writes the starter definition, prepares the output folders, and prints the next compile/check commands. Use axint init when you are wiring Axint into an existing Apple project or need the project-agent setup flags.

`axint compile <file>`

Full pipeline: parse → validate → generate → (optional sandbox + format).

Flag	What it does
`--out <path>`	Output path for the Swift file
`--target <name>`	Apple OS target (`ios17`, `ios18`, `ios26`, `macos14`, `macos15`, `macos26`)
`--sandbox`	Stage-4 SPM build verification
`--format`	Pipe output through `swift-format`
`--strict-format`	Fail if `swift-format` is missing or errors
`--emit-info-plist`	Emit `<Name>.plist.fragment.xml`
`--emit-entitlements`	Emit `<Name>.entitlements.fragment.xml`
`--json`	Machine-readable output

Axint also emits the local repair artifacts by default:

.axint/fix/latest.check.json
.axint/fix/latest.check.md
.axint/fix/latest.json
.axint/fix/latest.md

`axint validate <file>`

Parse + validate only. Faster than compile — skips Swift codegen and the sandbox stage. Good for live linting in editors and pre-commit hooks.

axint validate intents/SendMessage.intent.ts
axint validate intents/SendMessage.intent.ts --json

Flag	What it does
`--sandbox`	Still run sandbox validation on the hypothetically-generated Swift
`--json`	Machine-readable output (IR + diagnostics)

`axint validate-swift <path...>`

Validate existing Swift files against Axint’s Apple-specific rules.

axint validate-swift ios/Intents
axint validate-swift ios/Intents/LogWorkoutIntent.swift
axint validate-swift ios/Intents/LogWorkoutIntent.swift ios/Views/ComposerView.swift
axint validate-swift ios/Intents ios/Views --color

Use this when the Swift already exists and you want the Axint result plus the repair artifacts without recompiling from TypeScript.

By default, validate-swift strips ANSI color when stdout/stderr are not TTYs, so shell loops and CI logs stay readable. Pass --color to force colored output.

`axint suggest <app-description>`

Run the same planning pass as axint.suggest from the CLI when MCP transport is stale, closed, or unavailable.

axint suggest "A macOS AI-agent mission-control app for project rooms, handoffs, and operator review" --platform macOS
axint suggest "Existing SwiftUI comment box is visible but cannot be tapped" --platform iOS --json
axint workflow check --stage planning --session-token axsess_... --ran-suggest

The app description is the source of truth. --domain is only a weak hint, and --exclude can block stale context such as dating, fitness, or profile concepts when the current product is something else. Use --mode local for deterministic offline suggestions, or --mode pro when a signed-in Pro suggestion endpoint is configured.

`axint feature <description>`

Generate a feature package from a natural-language description, with optional surface, platform, token namespace, and explicit parameter hints.

axint feature "Log a water intake entry from Siri" --surface intent --platform ios
axint feature "Profile card with swipe actions" --surface view --platform macos --name ProfileCardView

Use this when an agent needs a first pass at multiple Apple-native files, then run axint validate-swift or Cloud Check on the generated Swift before shipping. If the prompt is really about a broken existing SwiftUI flow, Axint fails closed and points the agent to axint repair instead of replacing the working product surface with a fresh scaffold.

`axint repair <issue>`

Plan a project-aware repair for existing Apple app bugs. This is the flagship workflow when the Swift already exists and the problem is behavioral: a composer is visible but cannot be tapped, a macOS UI test says an element is not foreground, a runtime flow freezes, or a build log points at a hallucinated symbol.

axint project index --changed Sources/HomeComposer.swift Sources/FeedScreen.swift

axint repair "comment box is visible but cannot be tapped" \
  --source Sources/HomeComposer.swift \
  --platform ios \
  --actual "visible composer no longer accepts focus or typing" \
  --agent codex

axint repair "project action button is not foreground" \
  --platform macOS \
  --test-failure "should be hittable after scrolling; not foreground" \
  --format prompt

The command indexes the project, runs Cloud Check when a source file is available, ranks likely files, explains likely root causes, and returns the smallest patch/proof loop for the active host. Codex, Claude, Cursor, and Cowork get patch-first guidance; Xcode gets guarded Xcode workflow guidance. axint.suggest, axint.cloud.check, and axint.repair now share the same senior repair read, so input-focus, hit-testing, routing, layout, runtime, and build failures produce the same diagnosis and proof loop across tools.

By default it writes:

.axint/repair/latest.json
.axint/repair/latest.md
.axint/feedback/latest.json

The feedback packet is source-free by design. It includes project shape, diagnostic codes, issue class, redacted evidence, likely Axint owner, and the product action Axint should take if this pattern repeats.

`axint feedback`

Create or inspect the privacy-safe feedback packet that helps Axint learn from real user friction without collecting source code.

axint feedback create "Cloud Check missed a SwiftUI hit-testing blocker" \
  --source Sources/HomeComposer.swift \
  --runtime-failure "visible comment box cannot be tapped" \
  --format markdown

axint feedback latest --format json

Users should inspect the packet before sending it anywhere. The packet is intended for clustering repeated Apple-native failure modes into validator rules, repair classifiers, generator safeguards, docs fixes, or Cloud rule updates.

`axint telemetry`

Inspect or disable the source-free adoption heartbeat used for install and MCP usage proof.

axint telemetry status
axint telemetry status --format json
axint telemetry opt-out
axint telemetry opt-in

Telemetry is intentionally smaller than feedback. It can include Axint version, command class, MCP tool name, coarse host hint, OS family, Node major version, CI flag, and a random anonymous install ID.

It does not include:

source code
prompts
generated Swift bodies
command arguments
file names or local paths
credentials
machine identifiers

Environment-level opt out works too:

AXINT_TELEMETRY=off
AXINT_DISABLE_TELEMETRY=1
DO_NOT_TRACK=1

This is the signal that lets Axint Pulse separate “the package was downloaded” from “someone actually used Axint in a terminal, MCP host, or agent workflow.”

`axint schema compile <file>`

Compile a compact JSON schema into Swift without asking the agent to author a full TypeScript definition first.

axint schema compile feature.schema.json --out ios/Generated

The schema path supports intent, view, widget, app, and component shapes. It is best for low-token agent workflows where the contract is already structured.

`axint tokens ingest <file>`

Convert design tokens from JSON, JavaScript, TypeScript, or CSS into a SwiftUI token enum for generated views and components.

axint tokens ingest design-tokens.json --namespace SwarmTokens --out Sources/DesignTokens.swift

Use this before view generation when you want generated SwiftUI to reuse the project’s real colors, radii, spacing, and typography names.

`axint cloud check <file>`

Run the hosted Cloud Check path from the CLI so agents do not have to leave the editor and paste code into a browser.

axint cloud login
axint cloud status
axint cloud check ios/Intents/LogWorkoutIntent.swift --json
axint cloud check ios/Intents/LogWorkoutIntent.swift --feedback

Free checks return the release verdict and top issue. Signed-in Pro checks can return the richer repair payload for the next agent run.

Use --feedback when the check exposed an Axint-caused or Axint-missed bug. That prints the redacted learning signal the compiler team can cluster into a fixture, validator rule, generator fix, or docs update.

`axint status`

Print the exact running local Axint version, package path, tool count, and same-thread reload instructions. Use this at the top of a Codex, Claude, or Xcode agent session so the agent proves which MCP process it is actually connected to.

axint status
axint status --format json
axint status --format prompt

If the version is stale, update Axint, rerun the Xcode setup command, and reload only the Axint MCP server/tool process before editing project files. Keep the current chat when the client supports MCP reload.

`axint upgrade`

Check or apply a package upgrade without throwing away the current agent conversation.

axint upgrade
axint upgrade --apply
axint upgrade --apply --xcode-install
axint upgrade --target 0.4.23 --apply
axint upgrade --format prompt

The command returns the exact install plan plus a same-thread continuation prompt. In apply mode, Axint installs the target package, can refresh optional Xcode MCP wiring when --xcode-install is passed, and writes .axint/upgrade/latest.json plus .axint/upgrade/latest.md unless --no-write-report is passed.

From MCP, call axint.upgrade. The agent should keep the current thread, reload or reconnect only the Axint MCP server/tool process, call axint.status, and then continue with axint.session.start or the local context files instead of starting from scratch.

`axint doctor`

Audit version truth, Node/npm/npx paths, MCP project config, Axint project memory files, and Xcode agent setup.

axint doctor
axint doctor --dir /path/to/MyApp --expect 0.4.23
axint doctor --format json

Use this when Axint does not appear in a new agent chat, when Xcode is still using an old MCP server process, or when a project needs first-try setup proof.

`axint project init`

Write the project-local files that keep Axint top-of-mind for agents: .mcp.json, AGENTS.md, CLAUDE.md, .axint/project.json, and compact Axint memory/docs files.

axint project init
axint project init --dir /path/to/MyApp --name Swarm --agent xcode

Run this once per new Apple project before starting the first Xcode agent session.

`axint agent`

Install and query the local project brain that lets Codex, Claude, Cursor, Xcode, terminal users, and future agents coordinate through the same .axint truth layer.

axint agent install --dir /path/to/MyApp --agent codex
axint agent advice --dir /path/to/MyApp --agent codex --changed Sources/HomeComposer.swift Tests/HomeComposerUITests.swift
axint agent claim --dir /path/to/MyApp --agent codex --task "fix composer hit-testing" Sources/HomeComposer.swift
axint agent release --dir /path/to/MyApp --agent codex --all

agent install writes .axint/agent.json, .axint/context/latest.*, .axint/coordination/claims.json, and .axint/coordination/ledger.json. agent advice reads the latest run/repair proof, active claims, changed files, and host profile, then returns the safest next moves for the active tool. Use claims when multiple agents may be editing the same files.

`axint memory`

Build or inspect the local project memory index that keeps humans and agents on the same page across Codex, Claude, Cursor, Xcode, and terminal sessions.

axint memory index --dir /path/to/MyApp
axint memory index --dir /path/to/MyApp --changed Sources/HomeComposer.swift Tests/HomeComposerUITests.swift
axint memory index --cwd /path/to/MyApp --project-name MyApp --modified-files Sources/HomeComposer.swift --json

The index writes .axint/memory/latest.json and .axint/memory/latest.md. It summarizes project context, risky files, changed files, the latest run proof, latest repair packet, recent source-free feedback signals, and the next Axint commands an agent should run. Use it when multiple tools are touching the same Apple project or when an agent needs to rehydrate after MCP transport closes.

`axint session start`

Create .axint/session/current.json, preserve a token-scoped session record under .axint/session/sessions/, and print the compact context an agent must keep after a new chat, MCP restart, or conversation compaction.

axint session start
axint session start --project Swarm --platform macOS --agent xcode
axint session start --format json

The command returns a session token for axint.workflow.check, plus the docs and operating memory the agent should reload before touching Apple-native code. Parallel agents can start their own sessions without invalidating a still-fresh parent token.

`axint workflow check`

Run the workflow gate from the CLI when MCP is stale, disconnected, or not available in the current host. It mirrors the axint.workflow.check MCP tool so agents can still prove they rehydrated context, validated Swift, ran Cloud Check, and collected build/test evidence.

axint workflow check --stage planning --session-token axsess_...
axint workflow check --stage pre-commit --ran-swift-validate --ran-cloud-check --xcode-build-passed --xcode-tests-passed

Use this instead of inventing a manual checklist when the active tool bridge cannot call MCP.

`axint run`

Run Axint’s enforced Apple build loop for a real Apple project so the same pass owns session recovery, Swift validation, Cloud Check, xcodebuild, tests, and optional runtime proof.

axint run --dir /path/to/MyApp --agent codex --scheme MyApp --destination "platform=macOS"
axint run --dir /path/to/MyApp --agent codex --scheme MyApp --changed Sources/HomeComposer.swift --only-testing MyAppUITests/MyAppUITests/testComposerStillAcceptsInput
axint run --dir /path/to/MyApp --agent codex --scheme MyApp --runtime
axint run --dir /path/to/MyApp --agent codex --scheme MyApp --dry-run
axint run --dir /path/to/MyApp --agent codex --scheme MyApp --format json
axint run --dir /path/to/MyApp --agent codex --scheme MyApp --format json --include-source
axint run --cwd /path/to/MyApp --project-name MyApp --modified-files Sources/HomeComposer.swift --agent codex --dry-run
axint run status --dir /path/to/MyApp
axint run cancel --dir /path/to/MyApp --id axrun_...
axint runner once --dir /path/to/MyApp --agent codex --scheme MyApp

Use this when an agent has already generated code and now needs the proof loop to stay coherent instead of juggling separate local commands. Axint writes the latest run artifacts to .axint/run/latest.json and .axint/run/latest.md, including the next repair prompt when the pass fails. Passing focused --only-testing selectors are fed back into Cloud Check so stale UI/accessibility warnings do not override real focused Xcode proof.

For MCP-style CLI fallback, axint run also accepts --cwd as an alias for --dir, --modified and --modified-files as aliases for --changed, and --project-name when the active host already knows the project label. When Cloud Check creates a source-free learning signal, axint run writes it under .axint/feedback and includes the path in the run artifacts.

--format json is compact by default: it keeps verdict, evidence, diagnostics, artifact paths, and next actions visible while omitting full Swift source and trimming long command output. Use --include-source only when an agent needs inline source in the response.

Long runs also write .axint/run/jobs/<id>.json and .axint/run/latest-active.json. If an MCP client disconnects or a test run keeps going, use axint run status to rejoin the job and axint run cancel to stop the child process group.

axint runner once is the companion BYO-Mac entrypoint: it executes one queued job with the same Axint run pipeline on the connected machine.

`axint eject <file>`

Generate standalone Swift with no @axint/compiler dependency on the output side. Useful when you want the generated artifact to live independently of the Axint toolchain — drop it into Xcode and walk away.

axint eject intents/SendMessage.intent.ts \
  --out ios/Intents/SendMessageIntent.swift

`axint templates [name]`

List or fetch a bundled template.

axint templates                 # list all
axint templates --json          # machine-readable
axint templates send-message    # print the template source

`axint paint-test scaffold`

Generate a lightweight SwiftUI paint-test scaffold for visible view proof. Use this when static validation is clean but you still need a fast visual smoke harness before the full Xcode loop.

axint paint-test scaffold Sources/App/Views --out Tests/PaintTests

`axint mcp`

Start the MCP server on stdio. Used internally by .vscode/mcp.json and global MCP configs — you don’t normally invoke it by hand.

axint mcp
# Starts an MCP server speaking the Model Context Protocol over stdio.

`axint watch <file|dir>`

Keep recompiling a file or directory while you edit.

axint watch intents
axint watch intents/LogWorkout.intent.ts --out ios/Intents

This also refreshes the local Axint Check and Fix Packet on every rerun.

Registry commands

Axint also ships the package/registry flow:

axint login
axint publish
axint add namespace/package
axint search workout

`axint xcode <command>`

Xcode integration — install the Source Editor Extension, audit the local environment, and run mechanical Swift fixes without opening the IDE.

axint xcode install --project .
axint xcode setup
axint xcode guard
axint xcode verify
axint xcode doctor
axint project index --changed Sources/Feature.swift Sources/HomeView.swift
axint xcode check Sources/Feature.swift
axint xcode packet --kind validate
axint xcode packet --format prompt
axint xcode fix path/to/MyIntent.swift
axint xcode extension install
axint xcode extension status

install --project . is the current one-pass setup for a project. It writes the local agent config, project memory pack, Xcode guard proof, and durable MCP paths. setup / verify remain useful for narrower wiring checks, while guard prints the Xcode-specific proof gate an agent must satisfy before claiming an Apple UI repair is done. project index writes .axint/context/latest.* so Cloud Check can inspect related files before guessing. xcode check <file> is the direct file check for an existing Swift repair. doctor reports missing toolchains, entitlement gaps, and SDK drift. fix applies the mechanical subset of the Swift validator’s auto-repair suggestions to a file in place. The extension subcommands manage the notarized Source Editor Extension that surfaces Axint diagnostics inside Xcode.

The important distinction:

axint xcode packet
- latest result in the default markdown view
- add --format prompt for the full repair brief
- AI prompt
- packet JSON / markdown / path