kapi up

$ kapi up

Hold prosjektet oppdatert: oppskriften erklærer språkene, flyten og portene som avgjør om noe kan leveres; kapi up kjører prosjektets standardflyt (defaults.flow) over hvert målspråk, og løper i sløyfe til hvert portpassert omfang kan leveres eller er parkert for et menneske.

Uten defaults.flow kjører up den innebygde standardflyten — Minnegjenbruk (recycle) fulgt av AI-oversettelse — slik at en oppskrift ikke trenger noen flyt-YAML i det hele tatt for å ta igjen. Å sette defaults.flow erstatter den innebygde standarden.

Før hvert pass synkroniserer up prosjektets blokklagring med arbeidsträdet på nytt: redigerte kildefiler, en lagring skrevet av en annen kapi-versjon, eller en manglende lagring utløser en re-ekstrahering (den samme delte veien bak skrivebordets Re-ekstraher). --no-extract velger bort dette.

Hvert pass re-beregner dekning fra arbeidsträdet, kjører flyten bare for lokaler som fortsatt er under sin port, og stopper når alt leveres, et pass ikke gjør fremgang (resten parkeres — det trenger et menneske), eller passtaket er nådd. Etter hvert pass kjøres prosjektets bundne sjekker over det som ble produsert: en enhet med feilende funn (droppede plassholdere, terminologibrudd) teller som utkast, ikke oversatt, og kan derfor ikke løfte lokalet over porten før det er rettet. --no-checks velger bort dette.

Når sløyfen avsluttes, bestemmer materialiseringspolicyen om målspråksfiler skrives fra prosjektlagringen: 'defaults.materialize: on-converge' (eller --materialize-flagget) skriver dem for hvert lokal hvis portpasserte omfang alle kan leveres; standarden ('manual') overlater dette til 'kapi merge'.

Venue: i et servertilkoblet prosjekt (en oppskrift med en bowrain:-blokk, med bowrain-programtillegget installert) kjøres sløyfen på Bowrain-serveren som standard — på organisasjonens nøkler, mot organisasjonens delte minne og terminologi — og denne kommandoen dytter lokale endringer, streamer serverens live fremdrift og henter produserte mål. --local holder sløyfen på denne maskinen og dytter deretter resultatene slik at serveren aldri blir utdatert; --server feiler i stedet for å falle tilbake til en lokal kjøring. Den løste venue skrives ut først når oppskriften kobler til en server. Uten den blokken er up rent lokal.

--plan er en tørrkjøring i alle venue: i stedet for å kjøre noe rapporterer up det ventende arbeidet per (samling, lokal) — enheter som mangler et mål, eksakt Minneutnyttelse, gjenværende AI-arbeid og et grovt tokenestimat — beregnet lokalt mot arbeidsträdet, uten leverandøroppkall og uten skriving. Kombiner med --json for agenter.

up feiler aldri bygget på grunn av måldrift: parkert, ventende målinnhold er normal belastning, rapportert heller enn kastet. Bruk 'kapi status' for å inspisere status uten å kjøre noe, og 'kapi check --ship' for å håndheve portene (f.eks. før en utgivelsesmerking).

--passes 1 kjører ett enkelt pass (oppførselen til det nakne 'kapi run'); --passes N begrenser sløyfen til N pass.

Commandup

Groupwork

Try it

Runs in your browser against a small sample file. Edit the command before running, or press Run to execute it as shown.

$ kapi up # loop the default flow until every gated scope ships or parks

Flags

Flag	Type	Default	Description
--api-key	string		API key for the AI provider
--batching	string		how many blocks share one LLM call: auto (default), single
--concurrency , -j	int	0	number of files to process at once (0 = auto)
--context	string		what the model is told about a block besides the block: none, key (default), neighbours
--credential	string		saved credential name to use (see 'kapi credentials list')
--encoding , -e	string		input file encoding
--explain	bool	false	print the resolved source → sink bindings and exit without running
--fail-on-incomplete-watch	bool	false	server venue: fail when the run's event stream ends before the run does, instead of reporting it and pulling what landed
--fail-on-unknown	bool	false	exit with error if any file cannot be processed (default: skip with a warning)
--format , -f	string		override input format detection
--input , -i	stringSlice		input file path(s); repeat for multiple files
--instruction	string		extra guidance for the model while translating (e.g. "informal register; keep product names in English")
--jobs	int	0	how many languages to catch up concurrently per pass (0 = the recipe's defaults.jobs, else 4)
--json	bool	false	output the structured result as JSON
--local	bool	false	run the loop on this machine even when the recipe declares a server (the results are then pushed so the server stays current)
--materialize	bool	false	after the loop, write target-language files from the project store for every shippable locale (forces defaults.materialize: on-converge)
--memory	string		named Memory for recycle flow (resolves from KAPI_HOME)
--model	string		AI model name
--no-checks	bool	false	skip the bound checks in the loop (produced units count as translated even when failing guardrails)
--no-extract	bool	false	skip the pre-pass source-drift check and block-store re-extraction
--output , -o	string		output path or template (e.g. ./out/{name}_{lang}.{ext})
--pack	bool	false	when transforming a .kpz, also eject the result to the .kpz (auto-pack)
--parallel-blocks	int	0	fan out block processing across N goroutines (0 = off)
--passes	int	0	maximum reconciliation passes (0 = loop until up to date or parked, capped at 5; 1 = single pass)
--plan	bool	false	dry run: report pending work, content-memory leverage, and a token estimate per (collection, locale), with no provider calls and no writes
--project , -p	string		path to a kapi.yaml project recipe or its directory (auto-discovered from cwd if omitted)
--provider	string	anthropic	AI provider (anthropic, openai, ollama)
--server	bool	false	require the server venue: fail rather than run the loop locally when the recipe has no server or the server plumbing is unavailable
--source-lang	string		source language (e.g. en, en-US; defaults to the project's source_language, else en)
--stats	bool	false	include part/block counts in output
--strict	bool	false	alias for --fail-on-unknown
--target-lang	string		target language (e.g. fr, de-DE)
--termstore	string		named terms store for term-lookup/enforce (resolves from KAPI_HOME)
--timeout	duration	15m0s	server venue: maximum time to wait for the server run to finish before pulling available results
--trace	string		write flow trace JSON to file (for flow visualization)

More examples

$ kapi up --plan # dry run: pending work, content-memory leverage, and a token estimate per locale

$ kapi up --passes 1 # a single pass over every locale that needs work

$ kapi up --materialize # also write target-language files for the shippable locales

$ kapi up --local # connected project: run the loop on this machine, then push the results

$ kapi up -p kapi.yaml # bring an explicit project recipe up to date

← Back to the Command Reference