langctl 0.2.0 → 0.4.0

package/dist/commands/team.js

@@ -1,270 +1,81 @@
 import chalk from 'chalk';
-import ora from 'ora';
-import { isAuthenticated } from '../auth.js';
-import { getApiClient } from '../api.js';
-import { config } from '../config.js';
-/**
- * List all team members
- */
+import { CliError, ExitCode, notFoundError, usageError } from '../core/errors.js';
+import { getSession } from '../core/http.js';
+import { log, printJson, runtime, table } from '../core/output.js';
+import { confirm } from '../core/prompts.js';
+const ROLES = ['viewer', 'member', 'admin'];
+async function members(session) {
+    return session.api.get(`/orgs/${session.orgId}/members`);
+}
+async function requireMember(session, email) {
+    const m = (await members(session)).find(x => x.email.toLowerCase() === email.toLowerCase());
+    if (!m)
+        throw notFoundError(`No team member with email ${email}.`, 'List members with "langctl team list".');
+    return m;
+}
+function checkRole(role) {
+    if (!ROLES.includes(role))
+        throw usageError(`Invalid role "${role}".`, `Use one of: ${ROLES.join(', ')} (ownership is transferred in the web app).`);
+}
 export async function listTeamCommand() {
-    if (!isAuthenticated()) {
-        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const orgId = config.get('organizationId');
-    if (!orgId) {
-        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const spinner = ora('Fetching team members...').start();
-    try {
-        const api = getApiClient();
-        const members = await api.get(`/orgs/${orgId}/members`);
-        spinner.stop();
-        if (!members || members.length === 0) {
-            console.log(chalk.yellow('\nNo team members found\n'));
-            return;
-        }
-        console.log(chalk.blue.bold(`\n👥 Team Members (${members.length})\n`));
-        members.forEach((member) => {
-            console.log(chalk.white.bold(member.email));
-            console.log(chalk.gray(`  Role: ${member.role}`));
-            if (member.joinedAt) {
-                console.log(chalk.gray(`  Joined: ${new Date(member.joinedAt).toLocaleDateString()}`));
-            }
-            console.log('');
-        });
-    }
-    catch (error) {
-        spinner.fail(chalk.red('Failed to list team members'));
-        console.error(chalk.red(`Error: ${error.message}\n`));
-        process.exitCode = 1;
-    }
+    const session = await getSession();
+    const list = await members(session);
+    if (runtime.json)
+        return printJson(list);
+    table(list.map(m => [m.email, m.fullName ?? '', m.role, m.joinedAt ? new Date(m.joinedAt).toISOString().slice(0, 10) : '']), ['EMAIL', 'NAME', 'ROLE', 'JOINED']);
 }
-/**
- * Get team member details
- */
 export async function getTeamMemberCommand(email) {
-    if (!isAuthenticated()) {
-        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const orgId = config.get('organizationId');
-    if (!orgId) {
-        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const spinner = ora('Fetching member details...').start();
-    try {
-        const api = getApiClient();
-        const members = await api.get(`/orgs/${orgId}/members`);
-        const member = members.find((m) => m.email === email);
-        if (!member) {
-            throw new Error(`Member "${email}" not found`);
-        }
-        spinner.stop();
-        console.log(chalk.blue.bold('\n👤 Team Member Details\n'));
-        console.log(chalk.white.bold(`Email: ${member.email}`));
-        console.log(chalk.gray(`Role: ${member.role}`));
-        console.log(chalk.gray(`User ID: ${member.userId}`));
-        if (member.joinedAt) {
-            console.log(chalk.gray(`Joined: ${new Date(member.joinedAt).toLocaleString()}`));
-        }
-        console.log('');
-    }
-    catch (error) {
-        spinner.fail(chalk.red('Failed to get member details'));
-        console.error(chalk.red(`Error: ${error.message}\n`));
-        process.exitCode = 1;
-    }
+    const session = await getSession();
+    const m = await requireMember(session, email);
+    if (runtime.json)
+        return printJson(m);
+    log.out(`${chalk.bold(m.email)}  ${m.role}${m.fullName ? `  ${m.fullName}` : ''}`);
 }
-/**
- * Invite team member
- */
-export async function inviteTeamMemberCommand(email, options) {
-    if (!isAuthenticated()) {
-        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const orgId = config.get('organizationId');
-    if (!orgId) {
-        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const spinner = ora(`Inviting ${email}...`).start();
-    try {
-        const api = getApiClient();
-        await api.post(`/orgs/${orgId}/invitations`, {
-            email,
-            role: options.role || 'member'
-        });
-        spinner.succeed(chalk.green(`Invitation sent to ${email}`));
-        console.log('');
-    }
-    catch (error) {
-        spinner.fail(chalk.red('Failed to invite member'));
-        console.error(chalk.red(`Error: ${error.message}\n`));
-        process.exitCode = 1;
-    }
+export async function inviteTeamMemberCommand(email, opts) {
+    checkRole(opts.role);
+    const session = await getSession();
+    const inv = await session.api.post(`/orgs/${session.orgId}/invitations`, { email, role: opts.role });
+    if (runtime.json)
+        return printJson(inv);
+    log.success(`Invited ${chalk.bold(email)} as ${opts.role}`);
 }
-/**
- * Remove team member
- */
 export async function removeTeamMemberCommand(email) {
-    if (!isAuthenticated()) {
-        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const orgId = config.get('organizationId');
-    if (!orgId) {
-        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const spinner = ora(`Removing ${email}...`).start();
-    try {
-        const api = getApiClient();
-        const members = await api.get(`/orgs/${orgId}/members`);
-        const member = members.find((m) => m.email === email);
-        if (!member) {
-            throw new Error(`Member "${email}" not found`);
-        }
-        await api.delete(`/orgs/${orgId}/members/${member.id}`);
-        spinner.succeed(chalk.green(`Removed ${email} from organization`));
-        console.log('');
-    }
-    catch (error) {
-        spinner.fail(chalk.red('Failed to remove member'));
-        console.error(chalk.red(`Error: ${error.message}\n`));
-        process.exitCode = 1;
-    }
+    const session = await getSession();
+    const m = await requireMember(session, email);
+    if (!(await confirm(`Remove ${m.email} from the organization?`)))
+        throw new CliError('Cancelled.', ExitCode.Error);
+    await session.api.delete(`/orgs/${session.orgId}/members/${m.id}`);
+    if (runtime.json)
+        return printJson({ removed: m.email });
+    log.success(`Removed ${chalk.bold(m.email)}`);
 }
-/**
- * Update team member role
- */
 export async function updateTeamRoleCommand(email, role) {
-    if (!isAuthenticated()) {
-        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const validRoles = ['viewer', 'member', 'admin', 'owner'];
-    if (!validRoles.includes(role)) {
-        console.log(chalk.red(`✗ Invalid role. Must be one of: ${validRoles.join(', ')}\n`));
-        process.exitCode = 1;
-        return;
-    }
-    const orgId = config.get('organizationId');
-    if (!orgId) {
-        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const spinner = ora(`Updating role for ${email}...`).start();
-    try {
-        const api = getApiClient();
-        const members = await api.get(`/orgs/${orgId}/members`);
-        const member = members.find((m) => m.email === email);
-        if (!member) {
-            throw new Error(`Member "${email}" not found`);
-        }
-        await api.patch(`/orgs/${orgId}/members/${member.id}`, { role });
-        spinner.succeed(chalk.green(`Updated ${email} role to ${role}`));
-        console.log('');
-    }
-    catch (error) {
-        spinner.fail(chalk.red('Failed to update role'));
-        console.error(chalk.red(`Error: ${error.message}\n`));
-        process.exitCode = 1;
-    }
+    checkRole(role);
+    const session = await getSession();
+    const m = await requireMember(session, email);
+    await session.api.patch(`/orgs/${session.orgId}/members/${m.id}`, { role });
+    if (runtime.json)
+        return printJson({ email: m.email, role });
+    log.success(`${chalk.bold(m.email)} is now ${role}`);
 }
-/**
- * List invitations
- */
-export async function listInvitationsCommand(options) {
-    if (!isAuthenticated()) {
-        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const orgId = config.get('organizationId');
-    if (!orgId) {
-        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const spinner = ora('Fetching invitations...').start();
-    try {
-        const api = getApiClient();
-        const params = {};
-        if (options?.pending) {
-            params.status = 'pending';
-        }
-        const result = await api.get(`/orgs/${orgId}/invitations`, params);
-        const invitations = result.invitations || [];
-        spinner.stop();
-        if (invitations.length === 0) {
-            console.log(chalk.yellow('\nNo invitations found\n'));
-            return;
-        }
-        console.log(chalk.blue.bold(`\n✉️  Invitations (${invitations.length})\n`));
-        invitations.forEach((invitation) => {
-            console.log(chalk.white.bold(invitation.email));
-            console.log(chalk.gray(`  Role: ${invitation.role}`));
-            console.log(chalk.gray(`  Status: ${invitation.status}`));
-            if (invitation.createdAt) {
-                console.log(chalk.gray(`  Invited: ${new Date(invitation.createdAt).toLocaleDateString()}`));
-            }
-            if (invitation.expiresAt) {
-                console.log(chalk.gray(`  Expires: ${new Date(invitation.expiresAt).toLocaleDateString()}`));
-            }
-            console.log('');
-        });
-    }
-    catch (error) {
-        spinner.fail(chalk.red('Failed to list invitations'));
-        console.error(chalk.red(`Error: ${error.message}\n`));
-        process.exitCode = 1;
-    }
+export async function listInvitationsCommand(opts) {
+    const session = await getSession();
+    const status = opts.pending ? 'pending' : opts.status;
+    const { invitations } = await session.api.get(`/orgs/${session.orgId}/invitations`, { status });
+    if (runtime.json)
+        return printJson(invitations);
+    if (!invitations.length)
+        return log.info('No invitations.');
+    table(invitations.map(i => [i.email, i.role, i.status, i.expiresAt.slice(0, 10)]), ['EMAIL', 'ROLE', 'STATUS', 'EXPIRES']);
 }
-/**
- * Revoke invitation
- */
 export async function revokeInvitationCommand(email) {
-    if (!isAuthenticated()) {
-        console.log(chalk.red('✗ Not authenticated. Please run "langctl auth <api-key>" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const orgId = config.get('organizationId');
-    if (!orgId) {
-        console.log(chalk.red('✗ No organization configured. Please run "langctl init" first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-    const spinner = ora(`Revoking invitation for ${email}...`).start();
-    try {
-        const api = getApiClient();
-        const result = await api.get(`/orgs/${orgId}/invitations`);
-        const invitation = (result.invitations || []).find((inv) => inv.email === email && inv.status === 'pending');
-        if (!invitation) {
-            throw new Error(`No pending invitation found for "${email}"`);
-        }
-        await api.post(`/orgs/${orgId}/invitations/${invitation.id}/revoke`);
-        spinner.succeed(chalk.green(`Invitation for ${email} revoked`));
-        console.log('');
-    }
-    catch (error) {
-        spinner.fail(chalk.red('Failed to revoke invitation'));
-        console.error(chalk.red(`Error: ${error.message}\n`));
-        process.exitCode = 1;
-    }
+    const session = await getSession();
+    const { invitations } = await session.api.get(`/orgs/${session.orgId}/invitations`, { status: 'pending' });
+    const inv = invitations.find(i => i.email.toLowerCase() === email.toLowerCase());
+    if (!inv)
+        throw notFoundError(`No pending invitation for ${email}.`);
+    await session.api.post(`/orgs/${session.orgId}/invitations/${inv.id}/revoke`);
+    if (runtime.json)
+        return printJson({ revoked: inv.email });
+    log.success(`Revoked invitation for ${chalk.bold(inv.email)}`);
 }
-//# sourceMappingURL=team.js.map

package/dist/commands/translate.js

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+import { usageError } from '../core/errors.js';
+import { getSession } from '../core/http.js';
+import { log, printJson, runtime, spinner, table } from '../core/output.js';
+import { assertLanguages, getProject, listAllKeys, projectSlugFrom } from '../core/project.js';
+/** The API translates at most 50 strings per request. */
+const BATCH = 50;
+const isBlank = (v) => !v || !v.trim();
+/**
+ * Fill missing translations with AI (DeepL) from the project's default language.
+ * Counts against the plan's monthly AI translations unless the org uses its own DeepL key.
+ */
+export async function translateCommand(projectArg, opts) {
+    const session = await getSession();
+    const project = await getProject(session, projectSlugFrom(projectArg));
+    const source = project.defaultLanguage;
+    const targets = opts.to
+        ? opts.to.split(',').map(s => s.trim()).filter(Boolean)
+        : project.languages.filter(l => l !== source);
+    if (!targets.length)
+        throw usageError(`Project "${project.slug}" has no languages besides ${source}.`, `Add one with "langctl projects add-language ${project.slug} <code>".`);
+    assertLanguages(project, targets);
+    if (targets.includes(source))
+        throw usageError(`${source} is the source language and can't be a target.`);
+    const spin = spinner('Fetching keys…');
+    let keys;
+    try {
+        keys = await listAllKeys(session, project, { module: opts.module });
+    }
+    finally {
+        spin.stop();
+    }
+    if (opts.keys) {
+        const wanted = new Set(opts.keys.split(',').map(s => s.trim()).filter(Boolean));
+        const unknown = [...wanted].filter(k => !keys.some(key => key.key === k));
+        if (unknown.length)
+            throw usageError(`Key${unknown.length > 1 ? 's' : ''} not found: ${unknown.join(', ')}`);
+        keys = keys.filter(k => wanted.has(k.key));
+    }
+    // Work list: per target language, keys with source text whose target is empty (or all, with --overwrite)
+    const plan = targets.map(lang => ({
+        lang,
+        keys: keys.filter(k => !isBlank(k.translations?.[source]) && (opts.overwrite || isBlank(k.translations?.[lang]))),
+    }));
+    const total = plan.reduce((n, p) => n + p.keys.length, 0);
+    const noSource = keys.filter(k => isBlank(k.translations?.[source])).length;
+    if (opts.dryRun || total === 0) {
+        if (runtime.json) {
+            return printJson({ dryRun: Boolean(opts.dryRun), source, languages: plan.map(p => ({ language: p.lang, keys: p.keys.map(k => k.key) })), total });
+        }
+        table(plan.map(p => [p.lang, String(p.keys.length)]), ['language', opts.overwrite ? 'keys to retranslate' : 'missing']);
+        if (noSource)
+            log.info(chalk.dim(`${noSource} key(s) have no ${source} text and are skipped.`));
+        if (total === 0)
+            log.success('Nothing to translate.');
+        else
+            log.info(`Dry run: ${total} translation(s) would use ${total} AI translation(s). Run without --dry-run to translate.`);
+        return;
+    }
+    const done = [];
+    let usage;
+    let provider;
+    const progress = spinner(`Translating 0/${total}…`);
+    try {
+        for (const { lang, keys: todo } of plan) {
+            for (let i = 0; i < todo.length; i += BATCH) {
+                const batch = todo.slice(i, i + BATCH);
+                const res = await session.api.post(`/orgs/${session.orgId}/translate/bulk`, {
+                    items: batch.map(k => ({ text: k.translations[source], keyId: k.id })),
+                    sourceLang: source,
+                    targetLang: lang,
+                    projectId: project.id,
+                });
+                usage = res.usage;
+                provider = res.provider;
+                for (const [j, key] of batch.entries()) {
+                    const text = res.results[j]?.translatedText;
+                    if (!text)
+                        continue;
+                    await session.api.patch(`/orgs/${session.orgId}/projects/${project.id}/keys/${key.id}/translations/${encodeURIComponent(lang)}`, { value: text });
+                    done.push({ language: lang, key: key.key, text });
+                    progress.text = `Translating ${done.length}/${total}…`;
+                }
+            }
+        }
+    }
+    finally {
+        progress.stop();
+    }
+    if (runtime.json)
+        return printJson({ source, translated: done, provider, usage });
+    for (const d of done)
+        log.out(`${chalk.dim(d.language)}  ${d.key}  ${d.text}`);
+    const quota = provider === 'org'
+        ? 'using your own DeepL key'
+        : usage?.limit != null ? `${usage.used}/${usage.limit} AI translations used this month` : `${usage?.used ?? done.length} AI translations used this month`;
+    log.success(`Translated ${done.length} string(s) into ${plan.filter(p => p.keys.length).map(p => p.lang).join(', ')} (${quota}).`);
+    log.info(chalk.dim(`AI translations are held back from "langctl pull" until reviewed. Check them with "langctl review ${project.slug}", then approve with --approve (or edit them in the web app).`));
+}

package/dist/core/cache.js

@@ -0,0 +1,48 @@
+import { createHash } from 'crypto';
+import { mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { configDir } from './config.js';
+/**
+ * Small on-disk cache for conditional GETs (ETag / If-None-Match). When the server says
+ * "304 Not Modified" the CLI reuses the saved body, so repeated pulls cost almost nothing.
+ * Lives in the config dir (~/.langctl/cache); disable with LANGCTL_NO_CACHE=1.
+ */
+const MAX_ENTRIES = 40;
+function cacheDir() {
+    return join(configDir(), 'cache');
+}
+export function cacheEnabled() {
+    return !['1', 'true', 'yes'].includes(String(process.env.LANGCTL_NO_CACHE || '').toLowerCase());
+}
+/** Cache key covers the API, the key (orgs/scopes differ per key) and the full request URL. */
+export function cacheKey(apiUrl, apiKey, url) {
+    const keyId = createHash('sha256').update(apiKey).digest('hex').slice(0, 16);
+    return createHash('sha256').update(`${apiUrl}\n${keyId}\n${url}`).digest('hex').slice(0, 32);
+}
+export function readCache(key) {
+    try {
+        const entry = JSON.parse(readFileSync(join(cacheDir(), `${key}.json`), 'utf8'));
+        return entry && typeof entry.etag === 'string' ? entry : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCache(key, etag, data) {
+    try {
+        const dir = cacheDir();
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        writeFileSync(join(dir, `${key}.json`), JSON.stringify({ etag, data, savedAt: new Date().toISOString() }), { mode: 0o600 });
+        prune(dir);
+    }
+    catch {
+        // A cache that can't be written (read-only home, full disk) must never fail a command
+    }
+}
+function prune(dir) {
+    const files = readdirSync(dir).filter(f => f.endsWith('.json'))
+        .map(f => ({ f, t: statSync(join(dir, f)).mtimeMs }))
+        .sort((a, b) => b.t - a.t);
+    for (const { f } of files.slice(MAX_ENTRIES))
+        unlinkSync(join(dir, f));
+}

package/dist/core/config.js

@@ -0,0 +1,130 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join, resolve } from 'path';
+import { CliError, ExitCode, usageError } from './errors.js';
+export const DEFAULT_API_URL = 'https://api.langctl.com/api/v1';
+export function configDir() {
+    return process.env.LANGCTL_CONFIG_DIR ? resolve(process.env.LANGCTL_CONFIG_DIR) : join(homedir(), '.langctl');
+}
+export function configPath() {
+    return join(configDir(), 'config.json');
+}
+export function readUserConfig() {
+    const path = configPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        delete raw.__internal__; // left behind by the 0.2.x `conf` store
+        return raw;
+    }
+    catch {
+        throw new CliError(`Config file ${path} is not valid JSON.`, ExitCode.Error, 'Fix or delete it, then run "langctl auth --stdin" again.');
+    }
+}
+/** Write atomically with owner-only permissions — the file contains an API key. */
+export function writeUserConfig(next) {
+    const path = configPath();
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${process.pid}.tmp`;
+    const clean = Object.fromEntries(Object.entries(next).filter(([, v]) => v !== undefined && v !== ''));
+    writeFileSync(tmp, JSON.stringify(clean, null, 2) + '\n', { mode: 0o600 });
+    renameSync(tmp, path);
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch { /* not supported on Windows */ }
+}
+export function clearCredentials() {
+    const current = readUserConfig();
+    if (!current.apiKey)
+        return false;
+    const { apiKey: _k, organizationId: _o, organizationName: _n, ...rest } = current;
+    if (Object.keys(rest).length === 0) {
+        try {
+            unlinkSync(configPath());
+        }
+        catch { /* already gone */ }
+    }
+    else {
+        writeUserConfig(rest);
+    }
+    return true;
+}
+export const flagOverrides = {};
+export function resolveApiUrl() {
+    return (flagOverrides.apiUrl || process.env.LANGCTL_API_URL || readUserConfig().apiBaseUrl || DEFAULT_API_URL).replace(/\/+$/, '');
+}
+export function resolveCredentials() {
+    const apiUrl = resolveApiUrl();
+    if (flagOverrides.apiKey)
+        return { apiKey: normalizeApiKey(flagOverrides.apiKey), source: 'flag', apiUrl };
+    if (process.env.LANGCTL_API_KEY)
+        return { apiKey: normalizeApiKey(process.env.LANGCTL_API_KEY), source: 'env', apiUrl };
+    const cfg = readUserConfig();
+    if (cfg.apiKey)
+        return { apiKey: cfg.apiKey, source: 'config', apiUrl, organizationId: cfg.organizationId };
+    return null;
+}
+export function requireCredentials() {
+    const creds = resolveCredentials();
+    if (!creds) {
+        throw new CliError('Not authenticated.', ExitCode.Auth, 'Run "langctl auth --stdin" (or "langctl init"), or set LANGCTL_API_KEY in CI.');
+    }
+    return creds;
+}
+const KEY_RE = /^lc_[a-f0-9]{64}$/;
+/** Trim whitespace/quotes that commonly sneak in from copy-paste or CI secret stores. */
+export function normalizeApiKey(input) {
+    const key = input.trim().replace(/^['"]|['"]$/g, '').trim();
+    if (!KEY_RE.test(key)) {
+        throw new CliError('That does not look like a Langctl API key (expected "lc_" followed by 64 hex characters).', ExitCode.Auth, 'Copy the key from https://app.langctl.com/organization/api-keys — it is shown only once.');
+    }
+    return key;
+}
+export function maskApiKey(key) {
+    return `${key.slice(0, 7)}…${key.slice(-4)}`;
+}
+// ── Project config (langctl.json) ──────────────────────────────
+export const PROJECT_CONFIG_FILE = 'langctl.json';
+const KNOWN_KEYS = new Set(['$schema', 'project', 'format', 'output', 'languages', 'sourceLanguage', 'includeDrafts', 'module']);
+/** Find langctl.json in the current directory or the nearest parent. */
+export function loadProjectConfig(cwd = process.cwd()) {
+    let dir = resolve(cwd);
+    for (;;) {
+        const candidate = join(dir, PROJECT_CONFIG_FILE);
+        if (existsSync(candidate)) {
+            let config;
+            try {
+                config = JSON.parse(readFileSync(candidate, 'utf-8'));
+            }
+            catch (e) {
+                throw usageError(`${candidate} is not valid JSON: ${e.message}`);
+            }
+            const unknown = Object.keys(config).filter(k => !KNOWN_KEYS.has(k));
+            if (unknown.length) {
+                throw usageError(`${candidate} has unknown field(s): ${unknown.join(', ')}`, `Allowed: ${[...KNOWN_KEYS].filter(k => k !== '$schema').join(', ')}`);
+            }
+            if (config.languages !== undefined && !Array.isArray(config.languages)) {
+                throw usageError(`${candidate}: "languages" must be an array of language codes`);
+            }
+            return { config, path: candidate, root: dir };
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export function writeProjectConfig(path, config) {
+    const ordered = {
+        project: config.project,
+        format: config.format,
+        output: config.output,
+        ...(config.languages ? { languages: config.languages } : {}),
+        ...(config.sourceLanguage ? { sourceLanguage: config.sourceLanguage } : {}),
+        ...(config.includeDrafts ? { includeDrafts: true } : {}),
+        ...(config.module ? { module: config.module } : {}),
+    };
+    writeFileSync(path, JSON.stringify(ordered, null, 2) + '\n');
+}