@kolanut/language-packs 0.1.0

package/CONTRIBUTING.md

@@ -0,0 +1,119 @@
+# Contributing to Kola Language Packs
+
+Thank you for helping make programming accessible to African developers in their native languages! Your contribution, whether it's a new language pack, an improvement to an existing one, or feedback, is valuable to our community.
+
+## Who can contribute?
+
+We welcome contributions from:
+
+- **Native speakers** — Essential for new language packs and accuracy improvements
+- **Linguists and educators** — Help us ensure translations are culturally appropriate and pedagogically sound
+- **Developers** — Integrate these packs into other tools and platforms
+
+## Language pack structure
+
+Each language pack lives in its own folder under `packs/<name>/` and contains two key files:
+
+```
+packs/yoruba/
+├── pack.json       ← Main file with all metadata and keyword mappings
+└── keywords.json   ← Keyword mappings only (for easier tooling integration)
+```
+
+**Before you start:** Please read [packs/PACK_SCOPE.md](./packs/PACK_SCOPE.md) first. It explains the difference between language codes and country codes, and helps you choose the right scope when a country has multiple languages.
+
+### Required metadata: Geographic scope
+
+Every language pack must clearly declare which language variant it represents and where it's used. This helps contributors know exactly what belongs in each pack:
+
+```json
+{
+  "name": "nigerian-pidgin",
+  "languageCode": "pcm",
+  "locale": "pcm-NG",
+  "countries": ["NG"],
+  "regions": ["West Africa"],
+  "scopeNote": "Nigerian Pidgin (Naija) only. Not other West African creoles."
+}
+```
+
+| Field | Example | What it means |
+|-------|---------|---------------|
+| `languageCode` | `pcm` | ISO 639 language code (e.g., Nigerian Pidgin). **Important:** This is the language (`pcm`), not the country (`ng`). |
+| `locale` | `pcm-NG` | BCP-47 locale tag combining language and primary country |
+| `countries` | `["NG"]` | ISO 3166-1 country codes where this language variant is spoken |
+| `regions` | `["West Africa"]` | Geographic grouping for browsing and organization |
+| `scopeNote` | (free text) | Explains what's included in this pack and what belongs in future packs. Example: "Nigerian Pidgin only, not Cameroonian or Ghanaian creoles." |
+
+You can browse packs in `packs/index.json`, filter by country in `packs/by-country.json`, or by region in `packs/by-region.json`.
+
+**Translation quality:** Prefer phrasing you would actually use when teaching code. If you borrowed terms from another project or glossary, say so in the PR. Leave `reviewStatus` as `starter` — maintainers update it after review.
+
+### The token registry: What you need to translate
+
+**Every pack must translate all logical tokens in `packs/logical-tokens.json`** (currently **99 tokens** across core, standard, and advanced tiers).
+
+**Important rules:**
+- Don't create custom token keys — propose new tokens in a separate PR
+- Minimum enforced: `IF`, `FOR`, `FUNCTION`, `RETURN`, `PRINT`
+- New tokens may ship with English placeholders until a native speaker PR replaces them
+
+See `packs/target-coverage.json` for how each token maps to JavaScript, Python, TypeScript, Go, and Rust.
+
+### How to provide translations
+
+You can provide either a single translation or multiple aliases (for regional variants or different phrasings):
+
+**Single translation:**
+```json
+{
+  "LET": "make we say"
+}
+```
+
+**Multiple aliases (recommended):**
+```json
+{
+  "LET": ["make we say", "make", "let"]
+}
+```
+
+**Best practice:** When providing multiple aliases, include the English fallback as the last option. This helps learners transition between languages.
+
+### Transpilation targets
+
+Every pack must declare all five transpile backends (the transpiler picks the subset it needs per target language):
+
+```json
+"targets": ["javascript", "python", "typescript", "go", "rust"]
+```
+
+## Review process
+
+Here's what happens after you submit your contribution:
+
+1. **Submit your PR** — Please include only one language pack per pull request to make reviews easier
+2. **Native speaker review** — We'll find a native speaker to review your translations for accuracy and naturalness
+3. **Automated validation + coverage** — Our CI runs `npm test` (validation + official keyword coverage) to check technical correctness
+4. **Merge and release** — Once approved, we'll merge your PR and publish a patch release to npm
+
+**Estimated review time:** Most PRs are reviewed within 1-2 weeks, though this can vary depending on reviewer availability for less common languages.
+
+## Code of conduct
+
+We celebrate linguistic diversity and regional variations. Many African languages have multiple dialects and regional variants — and that's a strength, not a problem!
+
+**Our approach:**
+- **Embrace multiple variants** — Use alias arrays to include different regional expressions rather than choosing one "correct" form
+- **Be inclusive** — Nigerian Pidgin in Lagos sounds different from Port Harcourt; Yoruba in Nigeria differs from Benin. Include variations when appropriate
+- **Respect all contributors** — Be kind and constructive in reviews. Remember that language is personal and cultural
+
+## Need help?
+
+If you have questions, encounter issues, or need clarification:
+
+- **Open a GitHub issue** in the `kolanutTechnologies/kola-language-packs` repository
+- **Tag your issue** appropriately (`question`, `new-language`, `bug`, etc.)
+- **Be specific** — Include details about which language you're working on and what you need help with
+
+We're here to support you throughout the contribution process!

package/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Kolanut Technologies Ltd
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,237 @@
+# @kolanut/language-packs
+
+**Public open-source package** · Apache 2.0 · [Kolanut Technologies Ltd](https://kolacode.africa)
+
+Language packs for African-language programming: a consistent set of **logical programming concepts**, mapped to **native-language phrases**, with enough structure for tools to transpile to **JavaScript, Python, TypeScript, Go, and Rust**.
+
+If you’re building an editor, a transpiler, a linter, or a learning tool, this repo is the shared “source of truth”.
+
+## Why this exists (the gap we’re filling)
+
+Most tools that try “programming in African languages” run into the same wall:
+
+- **There’s no single public, spec-backed registry** that says *“these are the official reserved words for each target language”* and *“these are the logical concepts they map to”*.
+- Even when translation resources exist, they’re often **not packaged, not versioned, and not reusable** across tools.
+
+This project is our attempt to fix that properly:
+
+- A canonical **logical token registry** (the concepts)
+- A canonical **official keyword list per programming target** (the specs)
+- A growing set of **African language packs** (the human-language layer)
+- Validation so everyone can build on top of the same foundation with confidence
+
+## What’s in this repo
+
+- **25 shipped African language packs** (and a roadmap for more)
+- **99 logical tokens** that every pack maps (shared across all programming targets)
+- **Schemas + validation** to keep packs consistent
+- **Coverage checks** against official keyword lists for each target language
+
+The data lives under [`packs/`](./packs/). The package published to npm is `@kolanut/language-packs`.
+
+<!-- metrics:start -->
+
+## At a glance
+
+| What we cover | Shipped | Planned | Source of truth |
+|---|---:|---:|---|
+| **African language packs** | 25 | +40 | [`packs/coverage-summary.json`](./packs/coverage-summary.json) · [`packs/languages-roadmap.json`](./packs/languages-roadmap.json) |
+| **Programming targets** | 5 | +9 | [`packs/coverage-summary.json`](./packs/coverage-summary.json) · [`packs/languages-roadmap.json`](./packs/languages-roadmap.json) |
+| **Logical tokens** | 99 | — | [`packs/logical-tokens.json`](./packs/logical-tokens.json) |
+| **Keyword coverage gaps** | 0 | — | [`packs/coverage-summary.json`](./packs/coverage-summary.json) |
+
+<!-- metrics:end -->
+## Keyword coverage (0 gaps)
+
+We track coverage against official reserved keywords for each transpile target. Some concepts are “structural” (they don’t have a 1:1 keyword in a given language, but still need a consistent logical token).
+
+Source of truth: [`packs/coverage-summary.json`](./packs/coverage-summary.json)
+
+| Target | Spec keywords | Mapped | Gaps | Score |
+|--------|-------------:|-------:|-----:|------:|
+| JavaScript | 38 | 37 direct + 1 structural | 0 | 100% |
+| Python | 39 | 38 direct + 1 structural | 0 | 100% |
+| TypeScript | 64 tracked† | 63 direct + 1 structural | 0 | 100% |
+| Go | 25 | 25 | 0 | 100% |
+| Rust | 39 | 38 direct + 1 structural | 0 | 100% |
+
+†TypeScript has no single official keyword count in the Handbook; 64 is our tracked reserved/modifier set for coverage (see notes in `official-target-keywords.json`).
+
+## Spec sources (traceable and linkable)
+
+Source of truth: [`packs/official-target-keywords.json`](./packs/official-target-keywords.json)
+
+| Target | Spec keywords | Spec source |
+|--------|-------------:|------------|
+| JavaScript | 38 | [ECMA-262 §12.7.2 ReservedWord](https://tc39.es/ecma262/#sec-keywords-and-reserved-words) |
+| Python | 39 | [Python 3.12 — keywords](https://docs.python.org/3/reference/lexical_analysis.html#keywords) (35 hard + 4 soft) |
+| TypeScript | 64 tracked† | [TypeScript Handbook](https://www.typescriptlang.org/docs/handbook/intro.html) (no official count) |
+| Go | 25 | [Go spec — Keywords](https://go.dev/ref/spec#Keywords) |
+| Rust | 39 | [Rust Reference — strict keywords](https://doc.rust-lang.org/reference/keywords.html) |
+
+## Install
+
+```bash
+npm install @kolanut/language-packs
+```
+
+## Use it in code
+
+```typescript
+import { listPackNames, loadPack, flattenKeywords } from '@kolanut/language-packs';
+
+const packs = await listPackNames(); // e.g. 25 packs
+
+const yoruba = await loadPack('yoruba');
+const keywords = flattenKeywords(yoruba);
+// { IF: ['ṣé', 'if'], FOR: ['fun', 'for'], ... } — maps 99 logical tokens
+```
+
+## Use the raw JSON (no TS required)
+
+If you prefer to consume JSON directly (Rust/Go/Python/CLI tools), start here:
+
+- [`packs/index.json`](./packs/index.json): pack manifest (locale, region, countries, status)
+- [`packs/logical-tokens.json`](./packs/logical-tokens.json): the 99-token registry (the thing packs must fully map)
+- [`packs/by-country.json`](./packs/by-country.json): `NG` → `["yoruba", "igbo", ...]`
+- [`packs/by-region.json`](./packs/by-region.json): region → pack names
+- [`packs/coverage-summary.json`](./packs/coverage-summary.json): auto-generated coverage report
+- [`packs/languages-roadmap.json`](./packs/languages-roadmap.json): shipped vs planned packs
+
+## Languages shipped (25)
+
+These are the packs currently shipped in v0.1.
+
+- Flags are shown for the **primary locale** (quick scanning). Many packs apply to multiple countries—see [`packs/index.json`](./packs/index.json) for the full list.
+- **On GitHub, flags render as images**, so they should display even if your laptop doesn’t support emoji flags. (In some local Markdown previews, they may appear as squares.)
+
+**West Africa**
+- 🇳🇬 Yorùbá (`yo-NG`)
+- 🇳🇬 Nigerian Pidgin (`pcm-NG`)
+- 🇳🇬 Hausa (`ha-NG`)
+- 🇳🇬 Igbo (`ig-NG`)
+- 🇳🇬 Fulfulde (`ff-NG`)
+- 🇲🇱 Bambara (`bm-ML`)
+- 🇬🇭 Twi (`tw-GH`)
+- 🇸🇳 Wolof (`wo-SN`)
+- 🇸🇳 French (Africa) (`fr-SN`)
+
+**East Africa**
+- 🇰🇪 Swahili (`sw-KE`)
+- 🇪🇹 Amharic (`am-ET`)
+- 🇪🇹 Oromo (`om-ET`)
+- 🇪🇷 Tigrinya (`ti-ER`)
+- 🇷🇼 Kinyarwanda (`rw-RW`)
+- 🇺🇬 Luganda (`lg-UG`)
+
+**Central Africa**
+- 🇨🇩 Lingala (`ln-CD`)
+
+**Horn of Africa**
+- 🇸🇴 Somali (`so-SO`)
+
+**North / East Africa**
+- 🇪🇬 Arabic (Africa) (`ar-EG`)
+
+**Southern Africa**
+- 🇿🇦 isiZulu (`zu-ZA`)
+- 🇿🇦 isiXhosa (`xh-ZA`)
+- 🇿🇦 Afrikaans (`af-ZA`)
+- 🇱🇸 Sesotho (`st-LS`)
+- 🇧🇼 Setswana (`tn-BW`)
+- 🇿🇼 Shona (`sn-ZW`)
+- 🇦🇴 Portuguese (Africa) (`pt-AO`)
+
+Full metadata (including all countries per pack): [`packs/index.json`](./packs/index.json).
+
+## Language quality (and how it improves)
+
+Most packs start at `reviewStatus: "starter"`. That’s intentional: we’d rather ship useful starter packs quickly, then improve them through native-speaker review.
+
+If you care about linguistic accuracy or preferred terminology for a specific community, open a PR — see [`CONTRIBUTING.md`](./CONTRIBUTING.md).
+
+## Roadmap (what’s next)
+
+We track two roadmaps:
+
+- **Planned African languages** (by region + priority): [`packs/languages-roadmap.json`](./packs/languages-roadmap.json)
+- **Planned programming targets**: C, C++, Java, C#, Kotlin, Swift, Dart, Ruby, PHP
+
+Regional focus (how we’re sequencing the work):
+
+- **Phase 1 — West Africa + Central Africa**: highest immediate demand and strong community contributor base
+- **Phase 2 — East Africa + Horn of Africa**: expand coverage where multilingual education is already strong
+- **Phase 3 — North Africa + Southern Africa + Indian Ocean**: fill remaining gaps and add country-specific variants where needed
+
+High-priority upcoming packs currently include:
+
+- West Africa: Akan (`ak-GH`)
+- Central Africa: Cameroon Pidgin / Kamtok (`wes-CM`)
+
+## Contributing
+
+Contributions are welcome—especially from native speakers and educators.
+
+- **Improve an existing pack**: add better phrasing, aliases for dialects, or clearer scope notes
+- **Add a new pack**: follow the template, map all 99 tokens, and run validation
+
+Before contributing, please read [`packs/PACK_SCOPE.md`](./packs/PACK_SCOPE.md). It explains:
+
+- language codes vs country codes (e.g. `pcm` vs `NG`)
+- how we handle cross-border languages
+- when a dialect needs a new pack vs an alias in the same pack
+
+Quick start:
+
+```bash
+git clone https://github.com/kolanutTechnologies/kola-language-packs.git
+cd kola-language-packs
+npm install
+npm test       # validate + keyword coverage
+npm run build
+```
+
+Full guide: [`CONTRIBUTING.md`](./CONTRIBUTING.md).
+
+## Contributors
+
+This project only works if real people show up with real language knowledge. Thank you to everyone who’s contributed time, expertise, and care.
+
+[![Contributors](https://contrib.rocks/image?repo=kolanutTechnologies/kola-language-packs)](https://github.com/kolanutTechnologies/kola-language-packs/graphs/contributors)
+
+## FAQ
+
+### Is `packs/logical-tokens.json` exhaustive?
+
+It’s exhaustive for **this project’s current scope**: a shared registry of **logical concepts** needed to map official reserved keywords across five target languages (plus a small set of “structural” concepts).
+
+It is **not** a full programming-language grammar. It intentionally does **not** try to model:
+
+- punctuation (`;`, `{}`, `()`)
+- operators (`+`, `==`, `??`, `:=`)
+- comment syntax (`//`, `#`, `/* */`)
+- every syntax feature that isn’t keyword-driven
+
+If we expand into full syntax coverage later, that would likely be a separate registry (or multiple registries) rather than inflating “logical tokens” beyond readability.
+
+## Maintainers (optional)
+
+This section is only relevant if you’re maintaining the package or editing generated pack data.
+
+<details>
+<summary>Maintainer notes (publishing + regeneration)</summary>
+
+- Publishing: `npm publish --access public` (package is `@kolanut/language-packs`)
+- Regenerate derived pack files after changing the source definitions:
+
+```bash
+npm run bootstrap
+```
+
+</details>
+
+## License
+
+Apache 2.0 — see [LICENSE](./LICENSE).
+
+Some imported terminology may carry additional license terms (e.g. Mafoko/NOODL). Check source licenses before bulk import and cite them in your PR.

package/badges/coverage.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 1,
+  "label": "coverage",
+  "message": "0 gaps",
+  "color": "#16a34a"
+}

package/badges/packs.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 1,
+  "label": "packs",
+  "message": "25 shipped (+40)",
+  "color": "#2563eb"
+}

package/badges/targets.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 1,
+  "label": "targets",
+  "message": "5 shipped (+9)",
+  "color": "#7c3aed"
+}

package/badges/tokens.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 1,
+  "label": "logical tokens",
+  "message": "99",
+  "color": "#0ea5e9"
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { KeywordValue, LanguagePack, PackIndex, ResolvedKeyword } from './types.js';
+export { flattenKeywords, getPacksRoot, listPackNames, loadPack, resolveKeywords, } from './load-pack.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { flattenKeywords, getPacksRoot, listPackNames, loadPack, resolveKeywords, } from './load-pack.js';

package/dist/load-pack.d.ts

@@ -0,0 +1,6 @@
+import type { LanguagePack, ResolvedKeyword } from './types.js';
+export declare function getPacksRoot(): string;
+export declare function listPackNames(): Promise<string[]>;
+export declare function loadPack(name: string): Promise<LanguagePack>;
+export declare function resolveKeywords(pack: LanguagePack): ResolvedKeyword[];
+export declare function flattenKeywords(pack: LanguagePack): Record<string, string[]>;

package/dist/load-pack.js

@@ -0,0 +1,31 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const rootDir = join(dirname(fileURLToPath(import.meta.url)), '..');
+export function getPacksRoot() {
+    return join(rootDir, 'packs');
+}
+export async function listPackNames() {
+    const indexPath = join(getPacksRoot(), 'index.json');
+    const raw = await readFile(indexPath, 'utf8');
+    const index = JSON.parse(raw);
+    return index.packs.map((pack) => pack.name);
+}
+export async function loadPack(name) {
+    const packPath = join(getPacksRoot(), name, 'pack.json');
+    const raw = await readFile(packPath, 'utf8');
+    return JSON.parse(raw);
+}
+export function resolveKeywords(pack) {
+    return Object.entries(pack.keywords).map(([logical, value]) => ({
+        logical,
+        phrases: Array.isArray(value) ? value : [value],
+    }));
+}
+export function flattenKeywords(pack) {
+    const out = {};
+    for (const [logical, value] of Object.entries(pack.keywords)) {
+        out[logical] = Array.isArray(value) ? value : [value];
+    }
+    return out;
+}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+export type KeywordValue = string | string[];
+export interface LanguagePack {
+    name: string;
+    languageCode: string;
+    locale: string;
+    countries: string[];
+    regions: string[];
+    scopeNote?: string;
+    reviewStatus?: 'starter' | 'community-reviewed' | 'partner-verified';
+    recommendedPartners?: string[];
+    version: string;
+    displayName?: string;
+    description?: string;
+    contributors?: string[];
+    targets: Array<'javascript' | 'python' | 'typescript' | 'go' | 'rust'>;
+    keywords: Record<string, KeywordValue>;
+}
+export interface PackIndexEntry {
+    name: string;
+    languageCode: string;
+    locale: string;
+    displayName?: string;
+    countries: string[];
+    regions: string[];
+    version: string;
+}
+export interface PackIndex {
+    packs: PackIndexEntry[];
+}
+export interface ResolvedKeyword {
+    logical: string;
+    phrases: string[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/pack.schema.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/kolanutTechnologies/kola-language-packs/pack.schema.json",
+  "title": "Kola Language Pack",
+  "type": "object",
+  "required": ["name", "languageCode", "locale", "countries", "regions", "version", "targets", "keywords"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9-]*$",
+      "description": "Pack identifier, e.g. yoruba, pidgin"
+    },
+    "languageCode": {
+      "type": "string",
+      "pattern": "^[a-z]{2,3}$",
+      "description": "ISO 639 primary language subtag (e.g. yo, pcm, ha). Not a country code."
+    },
+    "locale": {
+      "type": "string",
+      "pattern": "^[a-z]{2,3}(-[A-Z]{2})?$",
+      "description": "BCP-47 language tag with optional region (e.g. pcm-NG, yo-NG)"
+    },
+    "countries": {
+      "type": "array",
+      "description": "ISO 3166-1 alpha-2 country codes where this pack variant applies",
+      "items": {
+        "type": "string",
+        "pattern": "^[A-Z]{2}$"
+      },
+      "minItems": 1
+    },
+    "regions": {
+      "type": "array",
+      "description": "Broad geographic scope for browsing (e.g. West Africa)",
+      "items": { "type": "string", "minLength": 1 },
+      "minItems": 1
+    },
+    "scopeNote": {
+      "type": "string",
+      "description": "Contributor guidance when a language spans countries or has distinct regional variants"
+    },
+    "reviewStatus": {
+      "type": "string",
+      "enum": ["starter", "community-reviewed", "partner-verified"],
+      "description": "Verification level of keyword translations"
+    },
+    "recommendedPartners": {
+      "type": "array",
+      "description": "Organizations to contact for verified terminology (language academies, universities, community NLP groups)",
+      "items": { "type": "string" }
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$"
+    },
+    "displayName": { "type": "string" },
+    "description": { "type": "string" },
+    "contributors": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "targets": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": ["javascript", "python", "typescript", "go", "rust"]
+      },
+      "minItems": 1
+    },
+    "keywords": {
+      "type": "object",
+      "description": "Logical token → native phrase(s). Value is string or string[].",
+      "additionalProperties": {
+        "oneOf": [
+          { "type": "string", "minLength": 1 },
+          {
+            "type": "array",
+            "items": { "type": "string", "minLength": 1 },
+            "minItems": 1
+          }
+        ]
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@kolanut/language-packs",
+  "version": "0.1.0",
+  "description": "Community-governed keyword maps for native African language programming — by Kolanut Technologies",
+  "license": "Apache-2.0",
+  "author": "Kolanut Technologies Ltd (https://kolacode.africa)",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./packs/*": "./packs/*",
+    "./schema": "./pack.schema.json"
+  },
+  "files": [
+    "dist",
+    "packs",
+    "badges",
+    "pack.schema.json",
+    "LICENSE",
+    "README.md",
+    "CONTRIBUTING.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "validate": "node scripts/validate.mjs",
+    "coverage": "node scripts/generate-coverage.mjs",
+    "bootstrap": "node scripts/bootstrap-packs.mjs",
+    "readme:metrics": "node scripts/update-readme-metrics.mjs",
+    "test": "npm run validate && npm run coverage",
+    "prepublishOnly": "npm run build && npm run validate"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kolanutTechnologies/kola-language-packs.git"
+  },
+  "keywords": [
+    "kolanut",
+    "kola-code",
+    "kolatech",
+    "african-languages",
+    "yoruba",
+    "pidgin",
+    "hausa",
+    "igbo",
+    "swahili",
+    "localization",
+    "programming-languages",
+    "definition-maps"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}