Ţéŕḿîñöļöĝý

neokapi ḿàñàĝéš ţéŕḿîñöļöĝý ŵîţĥ à çöñçéþţ-öŕîéñţéđ ḿöđéļ îñšþîŕéđ ƃý ţĥé ŢƂẊ (ŢéŕḿƂàšé éẊçĥàñĝé) šţàñđàŕđ: ļàñĝüàĝé-ñéüţŕàļ çöñçéþţš ĝŕöüþ ḿüļţî-ļöçàļé ţéŕḿš, éàçĥ çàŕŕýîñĝ à ļîƒéçýçļé šţàţüš àñđ öþţîöñàļ ĝŕàḿḿàţîçàļ ḿéţàđàţà. Ţĥé šàḿé ḿöđéļ ƃàçķš ţĥé kapi terms çöḿḿàñđš, ţĥé term-check, dnt-check àñđ term-extract þîþéļîñé ţööļš, àñđ ţĥé terms/ Ĝö ļîƃŕàŕý.

Çöñçéþţ-öŕîéñţéđ ḿöđéļ

À çöñçéþţ îš à ļàñĝüàĝé-ñéüţŕàļ ķñöŵļéđĝé üñîţ. Îţ çàŕŕîéš à đöḿàîñ àñđ à đéƒîñîţîöñ, àñđ ĝŕöüþš ţéŕḿš àçŕöšš ļöçàļéš. Éàçĥ ţéŕḿ ĥàš à ļîƒéçýçļé šţàţüš, àñđ à ļöçàļé ḿàý ĥöļđ šéṽéŕàļ ţéŕḿš (à þŕéƒéŕŕéđ ƒöŕḿ þļüš àđḿîţţéđ ṽàŕîàñţš).

Ţĥîš đîƒƒéŕš ƒŕöḿ à ƒļàţ ļîšţ öƒ šöüŕçé→ţàŕĝéţ þàîŕš àñđ îš ŵĥàţ éñàƃļéš ḿüļţîþļé ţéŕḿš þéŕ ļöçàļé, šţàţüš-đŕîṽéñ éñƒöŕçéḿéñţ, àñđ ŕîçĥ ḿéţàđàţà àţţàçĥéđ ţö à šîñĝļé ļàñĝüàĝé-ñéüţŕàļ çöñçéþţ.

Ţéŕḿ ļîƒéçýçļé šţàţüšéš

Šţàţüš	Ḿéàñîñĝ	Üšàĝé
`preferred`	Ţĥé ŕéçöḿḿéñđéđ ţéŕḿ	Àļŵàýš šüĝĝéšţ ţö ţŕàñšļàţöŕš
`approved`	Àççéþţéđ ƒöŕ üšé	Ṽàļîđ àļţéŕñàţîṽé
`admitted`	Àļļöŵéđ ƃüţ ñöţ ŕéçöḿḿéñđéđ	Šĥöŵ ŵîţĥ ļöŵéŕ þŕîöŕîţý
`deprecated`	Ƃéîñĝ þĥàšéđ öüţ	Ŵàŕñ ŵĥéñ ƒöüñđ îñ ţŕàñšļàţîöñš
`proposed`	Üñđéŕ ŕéṽîéŵ, ñöţ ýéţ àþþŕöṽéđ	Šĥöŵ àš šüĝĝéšţîöñ ŵîţĥ çàṽéàţ
`forbidden`	Ḿüšţ ñöţ ƃé üšéđ	Ƒļàĝ àš àñ éŕŕöŕ îñ çĥéçķš

Çöñçéþţ ŕéļàţîöñš

Çöñçéþţš àŕé ñöţ îšļàñđš. À ţéŕḿš šţöŕé þéŕšîšţš ţýþéđ, đîŕéçţéđ ŕéļàţîöñš ƃéţŵééñ çöñçéþţš, šö à ŕéñàḿéđ þŕöđüçţ þöîñţš àţ îţš ŕéþļàçéḿéñţ àñđ à đéþŕéçàţéđ ţéŕḿ þöîñţš àţ ţĥé öñé ţö üšé îñšţéàđ. Ţĥé ŕéļàţîöñ ṽöçàƃüļàŕý îš àļîĝñéđ ŵîţĥ ŠĶÖŠ:

Çàţéĝöŕý	Ļàƃéļš	Ḿéàñîñĝ
Ĥîéŕàŕçĥý	`broader`, `narrower`	À þàŕéñţ/çĥîļđ çöñçéþţ ŕéļàţîöñšĥîþ
Çöḿþöšîţîöñ	`part-of`, `has-part`	À ŵĥöļé/çöḿþöñéñţ ŕéļàţîöñšĥîþ
Àššöçîàţîöñ	`related`	À ñöñ-ĥîéŕàŕçĥîçàļ àššöçîàţîöñ
Šüççéššîöñ	`replaced-by`	À çöñçéþţ šüþéŕšéđéđ ƃý àñöţĥéŕ
Ĝüîđàñçé	`use-instead`	À đîšçöüŕàĝéđ ţéŕḿ þöîñţš àţ à þŕéƒéŕŕéđ öñé
Çŕöšš-šçĥéḿé	`exact-match`, `close-match`	Éǫüîṽàļéñçé àçŕöšš šçĥéḿéš
Šţàñçé	`competitor`	À çöḿþéţîţöŕ'š ţéŕḿ

Éàçĥ éđĝé îš à çöñçéþţ þöîñţîñĝ àţ àñöţĥéŕ üñđéŕ öñé öƒ ţĥöšé ļàƃéļš:

À ŕéļàţîöñ îš à ƒîŕšţ-çļàšš ŕéçöŕđ ŵîţĥ àñ ÎĐ, à šöüŕçé àñđ ţàŕĝéţ çöñçéþţ, à ţýþé ƒŕöḿ ţĥé ṽöçàƃüļàŕý àƃöṽé, àñ öþţîöñàļ ñöţé, àñđ àñ öþţîöñàļ ṽàļîđîţý (ƃéļöŵ). Ţĥé ţéŕḿš šţöŕé ṽàļîđàţéš ţĥàţ ţĥé ţýþé îš ķñöŵñ àñđ ţĥàţ ƃöţĥ çöñçéþţš éẋîšţ ƃéƒöŕé þéŕšîšţîñĝ àñ éđĝé.

Ŕéļàţîöñ àñđ ţéŕḿ ṽàļîđîţý

À ŕéļàţîöñ, àñđ àñ îñđîṽîđüàļ ţéŕḿ, ḿàý çàŕŕý à ṽàļîđîţý: à ĥàļƒ-öþéñ ţîḿé îñţéŕṽàļ [valid-from, valid-to) þļüš à šéţ öƒ ƒŕéé-ƒöŕḿ ţàĝš. À ǫüéŕý šüþþļîéš à šçöþé (à þöîñţ îñ ţîḿé àñđ à šéţ öƒ ţàĝš) àñđ öñļý éđĝéš àñđ ţéŕḿš ŵĥöšé ṽàļîđîţý ḿàţçĥéš ţĥé šçöþé àŕé ŕéţüŕñéđ. À ñîļ ṽàļîđîţý îš üñƃöüñđéđ (îţ ḿàţçĥéš éṽéŕý šçöþé); à ñîļ šçöþé àþþļîéš ñö ƒîļţéŕîñĝ.

Ţĥîš ḿàķéš ţĥé šàḿé ţéŕḿš šţöŕé àñšŵéŕ šçöþé-đéþéñđéñţ ǫüéšţîöñš: ŵĥîçĥ ţéŕḿš ŵéŕé þŕéƒéŕŕéđ àš öƒ ļàšţ ǫüàŕţéŕ, öŕ ŵĥîçĥ ŕéļàţîöñš ĥöļđ ŵîţĥîñ à ĝîṽéñ ḿàŕķéţ. Ţàĝš àŕé öþéñ-éñđéđ (ţĥé ƒŕàḿéŵöŕķ àššîĝñš ţĥéḿ ñö ḿéàñîñĝ); à çàļļéŕ çĥööšéš à ţàĝ ṽöçàƃüļàŕý (ƒöŕ éẋàḿþļé à market ķéý) àñđ üšéš îţ çöñšîšţéñţļý.

Šţàţüš ţŕàñšîţîöñš

À ţéŕḿ'š šţàţüš çĥàñĝéš öṽéŕ îţš ļîƒéţîḿé. ValidateTransition(from, to) àççéþţš àñý ţŕàñšîţîöñ ƃéţŵééñ ķñöŵñ šţàţüšéš (ĥîšţöŕý îš ţĥé ĝüàŕđ), ŵĥîļé IsGovernedTransition(from, to) ŕéþöŕţš ŵĥéţĥéŕ à çĥàñĝé îš çöñšéǫüéñţîàļ éñöüĝĥ ţö đéšéŕṽé ŕéṽîéŵ: àñý ţŕàñšîţîöñ ţö forbidden öŕ preferred, öŕ àñý ţŕàñšîţîöñ ƒŕöḿ forbidden. Ţĥé ƒŕàḿéŵöŕķ öñļý çļàššîƒîéš; à þļàţƒöŕḿ ƃüîļţ öñ îţ đéçîđéš ŵĥàţ ĝöṽéŕñàñçé à ĝöṽéŕñéđ ţŕàñšîţîöñ ŕéǫüîŕéš.

Šţöŕàĝé ƃàçķéñđš

Ţŵö ƃàçķéñđš šĥîþ îñ ţĥé terms/ þàçķàĝé, ƃöţĥ ţĥŕéàđ-šàƒé (ŔŴḾüţéẋ-þŕöţéçţéđ) àñđ îḿþļéḿéñţîñĝ ţĥé ƒüļļ Terminology îñţéŕƒàçé:

Îñ-ḿéḿöŕý (terms.NewInMemoryStore): ƒàšţ àñđ éþĥéḿéŕàļ, üšéđ ƒöŕ šéššîöñ-šçöþéđ ƃàţçĥ þŕöçéššîñĝ.
ŠǪĻîţé (terms.NewSQLiteStore): þéŕšîšţéñţ ƒîļé-ƃàšéđ šţöŕàĝé ƒöŕ ÇĻÎ ŵöŕķƒļöŵš, ŵîţĥ ƒüžžý ḿàţçĥîñĝ ṽîà ŠǪĻ-ƃàšéđ Ļéṽéñšĥţéîñ đîšţàñçé.

Ţĥé Terminology îñţéŕƒàçé àļšö àççöḿḿöđàţéš šéŕṽéŕ-šîđé ƃàçķéñđš ƒöŕ ḿüļţî-üšéŕ đéþļöýḿéñţš ŵîţĥ þŕöĵéçţ šçöþîñĝ, ţéŕḿîñöļöĝý šţŕéàḿš, àñđ ŵöŕķšþàçé îšöļàţîöñ.

ÇĻÎ üšàĝé

Ŕéšöüŕçé ļöçàţîöñ

Àļļ kapi terms çöḿḿàñđš (éẋçéþţ list) àççéþţ ţĥéšé ḿüţüàļļý éẋçļüšîṽé ƒļàĝš:

Ƒļàĝ	Ŕéšöļṽéš ţö	Éẋàḿþļé
`--name <n>`	`~/.config/kapi/terms/<n>.db`	`--name project-terms`
`--local`	`./terms.db` (çüŕŕéñţ đîŕéçţöŕý)	`--local`
`--file <path>`	Éẋþļîçîţ ƒîļé þàţĥ	`--file /shared/terms.db`
(ñö ƒļàĝ)	Šàḿé àš `--local`

Đàţàƃàšéš àŕé çŕéàţéđ öñ đéḿàñđ îƒ ţĥéý đöñ'ţ éẋîšţ. terms/ àñđ terms.db àŕé ţĥé öñ-đîšķ ñàḿéš ƒöŕ à ñàḿéđ öŕ ļööšé ţéŕḿš šţöŕé. ~/.config/kapi îš ţĥé üšéŕ çöñƒîĝ đîŕéçţöŕý öñ Ļîñüẋ, àñđ ŕéšöļṽéš ţö ~/Library/Application Support/kapi öñ ḿàçÖŠ. kapi config path þŕîñţš ţĥé ŕéšöļṽéđ ļöçàţîöñ.

Ŵîţĥ ñö ƒļàĝ îñšîđé à þŕöĵéçţ, ţĥé ţéŕḿš šţöŕé îš îñšţéàđ à šéţ öƒ ţàƃļéš îñ ţĥé þŕöĵéçţ'š .kapi/work/store.db, çöḿþîļéđ ƒŕöḿ ţĥé çöḿḿîţţéđ ƃüñđļé ţĥé ŕéçîþé ƃîñđš ŵîţĥ defaults.terms_source; šéé Ḿéḿöŕý & ţéŕḿš šţöŕàĝé.

# Import terms
kapi terms import terms.json --name project-terms

# Export terms
kapi terms export --name project-terms --format bundle -o terms.json

# Look up a term by its text or a form it declares (exact, or --fuzzy)
kapi terms lookup "encryption" --name project-terms -s en -t fr
kapi terms lookup "authenticating users" -s en -t fr --fuzzy

# Search concepts, view statistics, list named terms stores
kapi terms search "auth" -s en --limit 50
kapi terms stats --name project-terms
kapi terms list

# Inside a project: where the extracted content uses a term or a concept
kapi terms occurrences "content memory"
kapi terms occurrences c-dashboard --locale nb --collection docs

Ţĥé kapi terms çöḿḿàñđš çöṽéŕ îḿþöŕţ, éẋþöŕţ, ļööķüþ, šéàŕçĥ, öççüŕŕéñçéš, šţàţîšţîçš, àñđ ļîšţîñĝ. Îñšîđé à þŕöĵéçţ, à ţéŕḿ đéçîšîöñ àļšö ļàñđš ţĥŕöüĝĥ ţĥé öñé ŵŕîţé ṽéŕƃ: à kapi apply éñţŕý ŵîţĥ kind:"term" (op, term, locale, status, replaces, do_not_translate) îš ŵŕîţţéñ ţö ţĥé çöḿḿîţţéđ ţéŕḿš šöüŕçé ţĥé ŕéçîþé ƃîñđš ŵîţĥ defaults.terms_source àñđ çöḿþîļéđ îñţö ţĥé þŕöĵéçţ šţöŕé, šö git diff îš ţĥé ŕéṽîéŵ šüŕƒàçé. Çöñçéþţ ŕéļàţîöñš àŕé àüţĥöŕéđ ṽîšüàļļý ŕàţĥéŕ ţĥàñ ƒŕöḿ ţĥé çöḿḿàñđ ļîñé: Kapi Đéšķţöþ öþéñš à þéŕ-çöñçéþţ đàšĥƃöàŕđ (ţĥé @neokapi/concept-ui çöḿþöñéñţ, ŵĥîçĥ šĥöŵš à çöñçéþţ'š ţéŕḿš, ĝéöĝŕàþĥý, çöñšţŕàîñţš, à ļöçàļ ŕéļàţîöñš ŵîđĝéţ, àñđ à ţîḿéļîñé) öṽéŕ à ļöçàļ ţéŕḿš šţöŕé, ŵĥéŕé àñ éđîţöŕ àđđš, ŕéţýþéš, šçöþéš, àñđ ŕéḿöṽéš éđĝéš đîŕéçţļý. Ţĥé ŕéļàţîöñ đàţà ţĥîš þŕöđüçéš îš ţĥé šàḿé ConceptRelation ŕéçöŕđš þéŕšîšţéđ ƃý ţĥé ţéŕḿš šţöŕé àñđ ŕéàđ ţĥŕöüĝĥ ţĥé Ĝö ÀÞÎ ƃéļöŵ.

Þîþéļîñé îñţéĝŕàţîöñ

Ţĥŕéé þîþéļîñé ţööļš ƃŕîñĝ ţéŕḿîñöļöĝý îñţö ţĥé ƒļöŵ:

term-check šçàñš éàçĥ Ƃļöçķ'š šöüŕçé ţéẋţ ƒöŕ ţĥé ţéŕḿš à šţöŕé öŕ à ŕüļé ļîšţ çàŕŕîéš, àţţàçĥéš ţĥé ḿàţçĥéš àš term àññöţàţîöñš (šöüŕçé ţéŕḿ, ţàŕĝéţ šüĝĝéšţîöñš, þöšîţîöñš, šţàţüš), àñđ, ŵĥéŕé à ţàŕĝéţ éẋîšţš, çĥéçķš ţĥàţ îţ üšéš ţĥé éẋþéçţéđ ŕéñđéŕîñĝ. Ṽîöļàţîöñš àŕé ŕéþöŕţéđ àš ƒîñđîñĝš ŵîţĥ éẋþéçţéđ-ṽéŕšüš-àçţüàļ đéţàîļ, àñđ ţĥé ţööļ éẋîţš ñöñ-žéŕö öñ ţĥéḿ šö îţ đöüƃļéš àš à ĝàţé. Îţ ţàķéš îţš ŕüļéš ƒŕöḿ ţĥé þŕöĵéçţ'š ţéŕḿš šţöŕé (--termstore öüţšîđé à þŕöĵéçţ) öŕ ƒŕöḿ term_rules: îñ à ƒļöŵ šţéþ'š çöñƒîĝ: ţĥé šàḿé šĥàþé à ṽöîçé þŕöƒîļé'š ṽöçàƃüļàŕý üšéš (öñé term, îţš replacement, à severity, àñđ öþţîöñàļļý à concept_id ţĥàţ ţîéš ţĥé ŕüļé ţö à çöñçéþţ ĥéŕé). À çöñçéþţ ḿàŕķéđ đö-ñöţ-ţŕàñšļàţé ýîéļđš à ŕüļé ŵîţĥ ñö ŕéþļàçéḿéñţ, àñđ ţĥé çĥéçķ ƒàîļš à ţàŕĝéţ ţĥàţ đöéš ñöţ ķééþ îţš ţéŕḿ ṽéŕƃàţîḿ. À ţéŕḿ ŵŕîţţéñ îñ ţĥé šöüŕçé'š îñļîñé çöđé, à ǫüöţéđ kapi çöḿḿàñđ, àñ éẋàḿþļé çöḿḿàñđ ļîñé öŕ à ƒļàĝ ñàḿé öŵéš ñö ŕéñđéŕîñĝ, ƃéçàüšé çöđé ķééþš îţš ŵöŕđš îñ à ţŕàñšļàţîöñ; ţĥé þŕöšé àŕöüñđ îţ îš çĥéçķéđ àš üšüàļ. À ṽöîçé þŕöƒîļé'š ţéŕḿ ŕüļéš ļéàṽé çöđé öüţ ŵîţĥ scope: prose îñšţéàđ. À ŕüļé ŵĥöšé severity îš minor ŵàŕñš; àñý öţĥéŕ ṽàļüé, îñçļüđîñĝ üñšéţ, ƒàîļš, ƃéçàüšé à ŕüļé ŕéšöļṽéđ ƒŕöḿ à šţöŕé çàŕŕîéš ñö šéṽéŕîţý àñđ ḿüšţ ñöţ ƃé šîļéñţļý đöŵñĝŕàđéđ.
dnt-check (đö-ñöţ-ţŕàñšļàţé) ƒàîļš à ţàŕĝéţ ŵĥéŕé à ţéŕḿ ļîšţéđ üñđéŕ --terms (þŕöđüçţ ñàḿéš, ţŕàđéḿàŕķš, çöđé îđéñţîƒîéŕš) ŵàš ţŕàñšļàţéđ, ţŕàñšļîţéŕàţéđ öŕ đŕöþþéđ. Ţĥé ţŕàñšļàţé šţéþ ḿàšķš ţĥöšé šþàñš, šö ţĥé ḿöđéļ ñéṽéŕ šééš ţĥéḿ, šö îţ çàññöţ ƃé ţŕàñšļàţéđ. À çöñçéþţ ţĥé ţéŕḿš šţöŕé ḿàŕķš đö-ñöţ-ţŕàñšļàţé ţŕàṽéļš à đîƒƒéŕéñţ ŕöüţé: ţĥé ţŕàñšļàţé šţéþ àšķš ƒöŕ îţ îñ ţĥé þŕöḿþţ àš à ţéŕḿ ţö ķééþ ṽéŕƃàţîḿ, àñđ term-check ƒàîļš à ţàŕĝéţ ţĥàţ đöéš ñöţ ķééþ îţ.
term-extract šüŕƒàçéš çàñđîđàţé ţéŕḿš ƒŕöḿ ţĥé šöüŕçé, ƒöŕ à çüŕàţöŕ ţö àþþŕöṽé îñţö ţĥé šţöŕé.

Ţŵö ƒüŕţĥéŕ šţàĝéš éẋîšţ öñļý îñ ţĥé Ĝö ļîƃŕàŕý: term-lookup àñđ term-enforce (terms/tool.go, NewTermLookupTool àñđ NewTermEnforceTool). term-lookup šçàñš à Ƃļöçķ'š šöüŕçé ţéẋţ àñđ àţţàçĥéš ţĥé ḿàţçĥéš àš TermAnnotation éñţŕîéš; term-enforce çĥéçķš à ţŕàñšļàţéđ ƃļöçķ àĝàîñšţ ţĥé éẋþéçţéđ ţéŕḿîñöļöĝý àñđ ŕéçöŕđš ţĥé öüţçöḿé àš ƃļöçķ þŕöþéŕţîéš (term-enforce-passed, term-enforce-errors, term-enforce-violations). Ñéîţĥéŕ îš à ŕéĝîšţéŕéđ ţööļ: à ŕéçîþé çàññöţ ñàḿé ţĥéḿ àñđ kapi tools đöéš ñöţ ļîšţ ţĥéḿ. Ţĥé ŕüññéŕ àþþéñđš ƃöţĥ àüţöḿàţîçàļļý ƃéĥîñđ àñý ŕéĝîšţéŕéđ ţööļ ŵĥöšé šçĥéḿà đéçļàŕéš ţĥàţ îţ ŕéǫüîŕéš ţéŕḿš, ŵĥéñéṽéŕ à ţéŕḿš šţöŕé îš öþéñ, šö à ƒļöŵ šţéþ ĝéţš ţĥé ļööķüþ àñđ ţĥé éñƒöŕçéḿéñţ ŵîţĥöüţ ñàḿîñĝ éîţĥéŕ.

Ĝö ļîƃŕàŕý

Îñţéŕƒàçé

type Terminology interface {
    AddConcept(concept Concept) error
    GetConcept(id string) (Concept, bool)
    DeleteConcept(id string) error
    Lookup(sourceText string, opts LookupOptions) []TermMatch
    LookupAll(sourceText string, opts LookupOptions) []TermMatch
    Search(query string, sourceLocale, targetLocale model.LocaleID, offset, limit int) ([]Concept, int)

    // Relations between concepts, optionally validity-scoped.
    AddRelation(rel ConceptRelation) error
    DeleteRelation(id string) error
    RelationsOf(conceptID string, scope *graph.Scope) []ConceptRelation // both directions
    ListRelations(scope *graph.Scope) []ConceptRelation

    Count() int
    Concepts() []Concept
    Close() error
}

(Éṽéŕý ḿéţĥöđ, àñđ ţĥé îḿþöŕţ/éẋþöŕţ ĥéļþéŕš ƃéļöŵ, ţàķéš à context.Context àš îţš ƒîŕšţ àŕĝüḿéñţ àñđ ŕéţüŕñš àñ error àš îţš ļàšţ îñ ţĥé ŕéàļ ÀÞÎ; ƃöţĥ àŕé éļîđéđ ĥéŕé ƒöŕ ŕéàđàƃîļîţý.)

Lookup ƒîñđš ţĥé ƃéšţ ḿàţçĥ ƒöŕ à šîñĝļé ţéŕḿ. LookupAll šçàñš ŕüññîñĝ ţéẋţ àñđ ŕéţüŕñš éṽéŕý ţéŕḿ öççüŕŕéñçé ŵîţĥ þöšîţîöñš; ţĥîš îš ŵĥàţ þöŵéŕš ţĥé term-check ţööļ, ţĥé term-lookup ļîƃŕàŕý šţàĝé, àñđ éđîţöŕ šüĝĝéšţîöñš. Ƃý đéƒàüļţ LookupAll ḿàţçĥéš çàšé-îñšéñšîţîṽéļý (ţéŕḿîñöļöĝý šĥöüļđ ƃé ŕéçöĝñîžéđ ŕéĝàŕđļéšš öƒ çàþîţàļîžàţîöñ); šéţ CaseSensitive ţö öṽéŕŕîđé.

Ķéý ţýþéš

type Concept struct {
    ID         string
    Domain     string            // subject area (security, ui, marketing)
    Definition string            // language-neutral description
    Terms      []Term
    Properties map[string]string // extensible metadata
    CreatedAt  time.Time
    UpdatedAt  time.Time
}

type Term struct {
    Text         string
    Locale       model.LocaleID
    Status       model.TermStatus // preferred, approved, admitted, deprecated, proposed, forbidden
    PartOfSpeech string
    Gender       string
    Note         string
    Validity     *graph.Validity // optional time + tag scope (nil = unbounded)
}

type ConceptRelation struct {
    ID           string
    SourceID     string
    TargetID     string
    RelationType string          // a SKOS-aligned label: broader, use-instead, replaced-by, …
    Note         string
    Validity     *graph.Validity // optional time + tag scope (nil = unbounded)
    CreatedAt    time.Time
}

type TermMatch struct {
    Concept   Concept
    Term      Term                // the matched source term
    Score     float64             // 0.0-1.0
    MatchType model.MatchStrategy // exact, normalized, fuzzy
    Position  model.TextRange     // position in source text
}

type LookupOptions struct {
    SourceLocale  model.LocaleID
    TargetLocale  model.LocaleID
    CaseSensitive bool
    MinScore      float64             // minimum fuzzy score (default 0.8)
    MatchModes    []model.MatchStrategy
    Domains       []string            // restrict to specific domains
    StatusFilter  []model.TermStatus  // only return terms with these statuses
}

Concept ĥéļþéŕš: SourceTerm(locale), TargetTerms(locale), PreferredTerm(locale).

Éẋàḿþļé

package main

import (
    "fmt"

    "github.com/neokapi/neokapi/core/model"
    "github.com/neokapi/neokapi/terms"
)

func main() {
    tb := terms.NewInMemoryStore()
    defer tb.Close()

    tb.AddConcept(terms.Concept{
        ID:         "c1",
        Domain:     "security",
        Definition: "Process of encoding information",
        Terms: []terms.Term{
            {Text: "encryption", Locale: "en", Status: model.TermPreferred},
            {Text: "chiffrement", Locale: "fr", Status: model.TermPreferred},
        },
    })

    matches := tb.LookupAll(
        "The encryption module handles end-to-end encryption",
        terms.LookupOptions{SourceLocale: "en", TargetLocale: "fr"},
    )
    for _, m := range matches {
        fmt.Printf("Found %q at [%d:%d] → %s (%s)\n",
            m.Term.Text, m.Position.Start, m.Position.End,
            m.Concept.TargetTerms("fr")[0].Text, m.Term.Status)
    }
}

Îḿþöŕţ / éẋþöŕţ

// JSON preserves the full concept-oriented structure
count, err := terms.ImportJSON(tb, reader)
err = terms.ExportJSON(tb, writer, "Project Terms")

// CSV is a flat source/target form with optional metadata
opts := terms.CSVImportOptions{
    SourceLocale: "en", TargetLocale: "fr", Domain: "general", HasHeader: true,
}
count, err = terms.ImportCSV(tb, reader, opts)
err = terms.ExportCSV(tb, writer, "en", "fr", true)

ÇŠṼ çöļüḿñš àŕé source,target,domain (đöḿàîñ öþţîöñàļ). ĴŠÖÑ çàŕŕîéš ţĥé ƒüļļ çöñçéþţ šţŕüçţüŕé:

{
  "name": "Project Terms",
  "version": "1.0",
  "concepts": [
    {
      "id": "c1",
      "domain": "security",
      "definition": "Encryption where only endpoints can decrypt",
      "terms": [
        { "text": "end-to-end encryption", "locale": "en", "status": "preferred" },
        { "text": "chiffrement de bout en bout", "locale": "fr", "status": "preferred" }
      ]
    }
  ]
}