localingos 0.1.36 → 0.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "localingos",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "CLI tool to sync translations with Localingos",
   "main": "src/index.js",
   "type": "module",

package/src/api.js

@@ -6,7 +6,7 @@ export class LocalingosApi {
         this.apiKey = apiKey;
     }
 
-    async sync(familyId, translatables, { batchSize = 100, onProgress } = {}) {
+    async sync(projectId, translatables, { batchSize = 100, onProgress } = {}) {
         // Push in batches to avoid API timeout
         const batches = [];
         for (let i = 0; i < translatables.length; i += batchSize) {
@@ -15,7 +15,7 @@ export class LocalingosApi {
 
         for (let i = 0; i < batches.length; i++) {
             await this._post('/translatable', {
-                familyId,
+                projectId,
                 translatableList: batches[i]
             });
             if (onProgress) onProgress(Math.min((i + 1) * batchSize, translatables.length), translatables.length, 'push');
@@ -27,7 +27,7 @@ export class LocalingosApi {
         const pullBatchSize = 50;
         for (let i = 0; i < ids.length; i += pullBatchSize) {
             const batch = ids.slice(i, i + pullBatchSize);
-            const batchTranslations = await this._post(`/translation/${familyId}/batch`, { foreignIds: batch });
+            const batchTranslations = await this._post(`/translation/${projectId}/batch`, { foreignIds: batch });
             if (Array.isArray(batchTranslations)) allTranslations.push(...batchTranslations);
             if (onProgress) onProgress(Math.min(i + pullBatchSize, ids.length), ids.length, 'pull');
         }
@@ -38,23 +38,23 @@ export class LocalingosApi {
         return { translations: allTranslations, pending };
     }
 
-    async getTranslatables(familyId) {
-        return this._get(`/translatable/${familyId}`);
+    async getTranslatables(projectId) {
+        return this._get(`/translatable/${projectId}`);
     }
 
-    async getTranslations(familyId) {
-        return this._get(`/translation/${familyId}`);
+    async getTranslations(projectId) {
+        return this._get(`/translation/${projectId}`);
     }
 
-    async postTranslatables(familyId, translatableList) {
+    async postTranslatables(projectId, translatableList) {
         return this._post('/translatable', {
-            familyId,
+            projectId,
             translatableList
         });
     }
 
-    async deleteTranslatables(familyId, foreignIds) {
-        return this._request('DELETE', `/translatable/${familyId}`, { foreignIds });
+    async deleteTranslatables(projectId, foreignIds) {
+        return this._request('DELETE', `/translatable/${projectId}`, { foreignIds });
     }
 
     async _request(method, path, body) {

package/src/commands/init.js

@@ -57,9 +57,9 @@ export async function initCommand() {
         },
         {
             type: 'input',
-            name: 'familyId',
-            message: 'Family ID (copy from Families page → Family ID column):',
-            validate: (input) => input.trim().length > 0 || 'Family ID is required'
+            name: 'projectId',
+            message: 'Project ID (copy from Projects page → Project ID column):',
+            validate: (input) => input.trim().length > 0 || 'Project ID is required'
         },
         {
             type: 'input',
@@ -95,7 +95,7 @@ export async function initCommand() {
 
     const config = {
         apiKey: answers.apiKey.trim(),
-        familyId: answers.familyId.trim(),
+        projectId: answers.projectId.trim(),
         sourceLocale: answers.sourceLocale.trim(),
         format: answers.format,
         sourceFile: answers.sourceFile.trim(),

package/src/commands/mcp-serve.js

@@ -89,7 +89,7 @@ export async function mcpServeCommand() {
       }
       const entries = readSourceEntries(config, cwd);
       if (!entries.length) return { content: [{ type: 'text', text: 'No source strings found.' }] };
-      const result = await api('POST', '/sync', apiUrl, config.apiKey, { familyId: config.familyId, translatables: entries });
+      const result = await api('POST', '/sync', apiUrl, config.apiKey, { projectId: config.projectId, translatables: entries });
       const written = writeTranslations(result.translations || [], config, cwd);
       const pending = result.pending || [];
       const lines = [`Pushed ${entries.length} source strings`, `${(result.translations || []).length} translations available`,
@@ -102,18 +102,18 @@ export async function mcpServeCommand() {
   server.tool('localingos_push', 'Push source strings only.', {}, async () => {
     const entries = readSourceEntries(config, cwd);
     if (!entries.length) return { content: [{ type: 'text', text: 'No source strings found.' }] };
-    await api('POST', '/translatable', apiUrl, config.apiKey, { familyId: config.familyId, translatableList: entries });
+    await api('POST', '/translatable', apiUrl, config.apiKey, { projectId: config.projectId, translatableList: entries });
     return { content: [{ type: 'text', text: `Pushed ${entries.length} source strings.` }] };
   });
 
   server.tool('localingos_pull', 'Pull latest translations and write locale files.', {}, async () => {
-    const translations = await api('GET', `/translation/${config.familyId}`, apiUrl, config.apiKey);
+    const translations = await api('GET', `/translation/${config.projectId}`, apiUrl, config.apiKey);
     if (!translations?.length) return { content: [{ type: 'text', text: 'No translations available yet.' }] };
     const written = writeTranslations(translations, config, cwd);
     return { content: [{ type: 'text', text: `Pulled:\n${written.join('\n')}` }] };
   });
 
-  server.tool('localingos_status', 'Show project status: family, locales, key counts.', {}, async () => {
+  server.tool('localingos_status', 'Show project status: project, locales, key counts.', {}, async () => {
     const entries = readSourceEntries(config, cwd);
     const outputDir = path.resolve(cwd, config.outputDir);
     let locales = [];
@@ -121,7 +121,7 @@ export async function mcpServeCommand() {
       const re = new RegExp('^' + (config.outputPattern || '{locale}.json').replace('{locale}', '(.+)').replace('.', '\\.') + '$');
       locales = fs.readdirSync(outputDir).map(f => f.match(re)?.[1]).filter(Boolean);
     }
-    return { content: [{ type: 'text', text: `Family: ${config.familyId}\nSource: ${config.sourceLocale}\nKeys: ${entries.length}\nTranslations: ${locales.join(', ') || 'none'}` }] };
+    return { content: [{ type: 'text', text: `Project: ${config.projectId}\nSource: ${config.sourceLocale}\nKeys: ${entries.length}\nTranslations: ${locales.join(', ') || 'none'}` }] };
   });
 
   server.tool('localingos_search', 'Search translation keys or text.',
@@ -148,44 +148,44 @@ export async function mcpServeCommand() {
     }
   );
 
-  // ── Family management tools ───────────────────────────────────────────
+  // ── Project management tools ───────────────────────────────────────────
 
-  server.tool('localingos_family_members', 'List members of a family.',
-    { familyId: z.string().describe('Family ID') },
-    async ({ familyId }) => {
-      const members = await api('GET', `/family/${familyId}/members`, apiUrl, config.apiKey);
+  server.tool('localingos_project_members', 'List members of a project.',
+    { projectId: z.string().describe('Project ID') },
+    async ({ projectId }) => {
+      const members = await api('GET', `/project/${projectId}/members`, apiUrl, config.apiKey);
       if (!members?.length) return { content: [{ type: 'text', text: 'No members found.' }] };
       const lines = members.map(m => `${m.userId} — ${m.authorization}`);
       return { content: [{ type: 'text', text: `${members.length} member(s):\n${lines.join('\n')}` }] };
     }
   );
 
-  server.tool('localingos_add_member', 'Add a member to a family (admin only).',
-    { familyId: z.string(), userId: z.string().describe('User ID to add'), role: z.enum(['ADMIN', 'WRITE', 'READ']).default('WRITE').describe('Role for the new member') },
-    async ({ familyId, userId, role }) => {
+  server.tool('localingos_add_member', 'Add a member to a project (admin only).',
+    { projectId: z.string(), userId: z.string().describe('User ID to add'), role: z.enum(['ADMIN', 'WRITE', 'READ']).default('WRITE').describe('Role for the new member') },
+    async ({ projectId, userId, role }) => {
       try {
-        await api('POST', `/family/${familyId}/members`, apiUrl, config.apiKey, { userId, authorization: role });
-        return { content: [{ type: 'text', text: `Added ${userId} as ${role} to family ${familyId}` }] };
+        await api('POST', `/project/${projectId}/members`, apiUrl, config.apiKey, { userId, authorization: role });
+        return { content: [{ type: 'text', text: `Added ${userId} as ${role} to project ${projectId}` }] };
       } catch (e) { return { content: [{ type: 'text', text: `Failed: ${e.message}` }] }; }
     }
   );
 
-  server.tool('localingos_remove_member', 'Remove a member from a family (admin only).',
-    { familyId: z.string(), userId: z.string().describe('User ID to remove') },
-    async ({ familyId, userId }) => {
+  server.tool('localingos_remove_member', 'Remove a member from a project (admin only).',
+    { projectId: z.string(), userId: z.string().describe('User ID to remove') },
+    async ({ projectId, userId }) => {
       try {
-        await api('DELETE', `/family/${familyId}/members/${userId}`, apiUrl, config.apiKey);
-        return { content: [{ type: 'text', text: `Removed ${userId} from family ${familyId}` }] };
+        await api('DELETE', `/project/${projectId}/members/${userId}`, apiUrl, config.apiKey);
+        return { content: [{ type: 'text', text: `Removed ${userId} from project ${projectId}` }] };
       } catch (e) { return { content: [{ type: 'text', text: `Failed: ${e.message}` }] }; }
     }
   );
 
-  server.tool('localingos_billing_status', 'Show billing status for a family — plan, usage, owner.',
-    { familyId: z.string().describe('Family ID') },
-    async ({ familyId }) => {
+  server.tool('localingos_billing_status', 'Show billing status for a project — plan, usage, owner.',
+    { projectId: z.string().describe('Project ID') },
+    async ({ projectId }) => {
       try {
-        const b = await api('GET', `/family/${familyId}/billing-status`, apiUrl, config.apiKey);
-        if (!b.attached) return { content: [{ type: 'text', text: 'No billing attached to this family.' }] };
+        const b = await api('GET', `/project/${projectId}/billing-status`, apiUrl, config.apiKey);
+        if (!b.attached) return { content: [{ type: 'text', text: 'No billing attached to this project.' }] };
         const lines = [
           `Status: ${b.accessMode}${b.planName ? ' · ' + b.planName : ''}`,
           `Owner: ${b.ownerEmail || b.ownerUserId}`,
@@ -197,22 +197,22 @@ export async function mcpServeCommand() {
     }
   );
 
-  server.tool('localingos_attach_billing', 'Attach your billing account to a family (admin only).',
-    { familyId: z.string() },
-    async ({ familyId }) => {
+  server.tool('localingos_attach_billing', 'Attach your billing account to a project (admin only).',
+    { projectId: z.string() },
+    async ({ projectId }) => {
       try {
-        await api('POST', `/family/${familyId}/billing/attach`, apiUrl, config.apiKey);
-        return { content: [{ type: 'text', text: `Billing attached to family ${familyId}` }] };
+        await api('POST', `/project/${projectId}/billing/attach`, apiUrl, config.apiKey);
+        return { content: [{ type: 'text', text: `Billing attached to project ${projectId}` }] };
       } catch (e) { return { content: [{ type: 'text', text: `Failed: ${e.message}` }] }; }
     }
   );
 
-  server.tool('localingos_detach_billing', 'Detach billing from a family (admin only). Family becomes read-only.',
-    { familyId: z.string() },
-    async ({ familyId }) => {
+  server.tool('localingos_detach_billing', 'Detach billing from a project (admin only). Project becomes read-only.',
+    { projectId: z.string() },
+    async ({ projectId }) => {
       try {
-        await api('POST', `/family/${familyId}/billing/detach`, apiUrl, config.apiKey);
-        return { content: [{ type: 'text', text: `Billing detached from family ${familyId}` }] };
+        await api('POST', `/project/${projectId}/billing/detach`, apiUrl, config.apiKey);
+        return { content: [{ type: 'text', text: `Billing detached from project ${projectId}` }] };
       } catch (e) { return { content: [{ type: 'text', text: `Failed: ${e.message}` }] }; }
     }
   );

package/src/commands/pull.js

@@ -9,12 +9,12 @@ export async function pullCommand(options) {
     const apiUrl = resolveApiUrl(options.env);
     const formatter = getFormatter(config.format);
 
-    console.log(chalk.blue(`⬇️  Pulling translations for family ${config.familyId}...`));
+    console.log(chalk.blue(`⬇️  Pulling translations for project ${config.projectId}...`));
     const api = new LocalingosApi(apiUrl, config.apiKey);
 
     let translations;
     try {
-        translations = await api.getTranslations(config.familyId);
+        translations = await api.getTranslations(config.projectId);
     } catch (e) {
         console.error(chalk.red(`\nPull failed: ${e.message}`));
         process.exit(1);

package/src/commands/push.js

@@ -56,11 +56,11 @@ export async function pushCommand(options) {
     }
 
     // 2. Push to API
-    console.log(chalk.blue(`\n⬆️  Pushing ${translatables.length} translatables to family ${config.familyId}...`));
+    console.log(chalk.blue(`\n⬆️  Pushing ${translatables.length} translatables to project ${config.projectId}...`));
     const api = new LocalingosApi(apiUrl, config.apiKey);
 
     try {
-        await api.postTranslatables(config.familyId, translatables);
+        await api.postTranslatables(config.projectId, translatables);
     } catch (e) {
         console.error(chalk.red(`\nPush failed: ${e.message}`));
         process.exit(1);

package/src/commands/sync.js

@@ -70,12 +70,12 @@ export async function syncCommand(options) {
     }
 
     // 2. Call /sync endpoint (push + pull in one call)
-    console.log(chalk.blue(`\n🔄 Syncing with Localingos (family: ${config.familyId})...`));
+    console.log(chalk.blue(`\n🔄 Syncing with Localingos (project: ${config.projectId})...`));
     const api = new LocalingosApi(apiUrl, config.apiKey);
 
     let result;
     try {
-        result = await api.sync(config.familyId, translatables, {
+        result = await api.sync(config.projectId, translatables, {
             onProgress: (done, total, phase) => {
                 const label = phase === 'push' ? 'Pushed' : 'Pulled';
                 process.stdout.write(`\r   ${label} ${done}/${total} strings...`);
@@ -94,11 +94,11 @@ export async function syncCommand(options) {
         console.log(chalk.yellow(`   ⏳ ${pending.length} keys pending translation: ${pending.slice(0, 5).join(', ')}${pending.length > 5 ? '...' : ''}`));
     }
 
-    // 2b. Prune stale translatables from the remote family
+    // 2b. Prune stale translatables from the remote project
     if (options.prune) {
-        console.log(chalk.blue('\n🔍 Checking for stale translatables in the remote family...'));
+        console.log(chalk.blue('\n🔍 Checking for stale translatables in the remote project...'));
         try {
-            const remoteTranslatables = await api.getTranslatables(config.familyId);
+            const remoteTranslatables = await api.getTranslatables(config.projectId);
             const localIds = new Set(translatables.map(t => t.id));
             const staleIds = remoteTranslatables
                 .filter(t => !localIds.has(t.foreignId || t.id))
@@ -111,7 +111,7 @@ export async function syncCommand(options) {
                 }
                 if (staleIds.length > 10) console.log(chalk.gray(`     ... and ${staleIds.length - 10} more`));
 
-                const deleteResult = await api.deleteTranslatables(config.familyId, staleIds);
+                const deleteResult = await api.deleteTranslatables(config.projectId, staleIds);
                 console.log(chalk.green(`   🗑️  Deleted ${deleteResult.deleted} stale translatable(s) from remote`));
             } else {
                 console.log(chalk.green('   ✅ No stale translatables found'));

package/src/config.js

@@ -6,7 +6,7 @@ import chalk from 'chalk';
  * Config resolution order:
  *
  * 1. localingos.config.json  — committed to repo, shared with team/CI
- *    Contains: familyId, sourceLocale, format, sourceFile, outputDir, outputPattern, apiKeyEnv
+ *    Contains: projectId, sourceLocale, format, sourceFile, outputDir, outputPattern, apiKeyEnv
  *
  * 2. .localingos.json         — in .gitignore, local dev only
  *    Contains: apiKey (and can override any field from the committed config)
@@ -90,7 +90,7 @@ function resolveApiKey(config) {
         config.apiKey = process.env[envVarName];
     }
 
-    const required = ['apiKey', 'familyId', 'sourceLocale', 'format', 'sourceFile', 'outputDir'];
+    const required = ['apiKey', 'projectId', 'sourceLocale', 'format', 'sourceFile', 'outputDir'];
     const missing = required.filter(field => !config[field]);
     if (missing.length > 0) {
         if (missing.length === 1 && missing[0] === 'apiKey') {