@vocoder/cli 0.9.0 → 0.11.0

package/dist/{chunk-IZN5HVYD.mjs → chunk-XF3KGGYQ.mjs}

@@ -43568,6 +43568,687 @@ var require_brace_expansion = __commonJS({
   }
 });
 
+// src/utils/api.ts
+function isLimitErrorResponse(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.errorCode === "string" && typeof candidate.limitType === "string" && typeof candidate.planId === "string" && typeof candidate.current === "number" && typeof candidate.required === "number" && typeof candidate.upgradeUrl === "string" && typeof candidate.message === "string";
+}
+function isSyncPolicyErrorResponse(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return (candidate.errorCode === "BRANCH_NOT_ALLOWED" || candidate.errorCode === "PROJECT_REPOSITORY_MISMATCH") && typeof candidate.message === "string";
+}
+function extractErrorMessage(payload, fallback) {
+  if (!payload || typeof payload !== "object") {
+    return fallback;
+  }
+  const candidate = payload;
+  if (typeof candidate.message === "string") {
+    return candidate.message;
+  }
+  if (typeof candidate.error === "string") {
+    return candidate.error;
+  }
+  return fallback;
+}
+function parsePayload(raw) {
+  if (raw.length === 0) {
+    return null;
+  }
+  const trimmed = raw.trimStart();
+  if (trimmed.startsWith("<!DOCTYPE") || trimmed.startsWith("<html")) {
+    return {
+      message: "Unexpected response from server (received HTML). Check your network connection or try again."
+    };
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { message: raw };
+  }
+}
+async function readPayload(response) {
+  if (typeof response.text === "function") {
+    const raw = await response.text();
+    return parsePayload(raw);
+  }
+  if (typeof response.json === "function") {
+    return response.json();
+  }
+  return null;
+}
+var VocoderAPIError = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.name = "VocoderAPIError";
+    this.status = params.status;
+    this.payload = params.payload;
+    this.limitError = params.limitError ?? null;
+    this.syncPolicyError = params.syncPolicyError ?? null;
+  }
+};
+var VocoderAPI = class {
+  constructor(config) {
+    this.apiUrl = config.apiUrl;
+    this.apiKey = config.apiKey;
+  }
+  async request(path2, init = {}, errorPrefix) {
+    const response = await fetch(`${this.apiUrl}${path2}`, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        ...init.headers ?? {}
+      }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      const limitError = isLimitErrorResponse(payload) ? payload : null;
+      const syncPolicyError = isSyncPolicyErrorResponse(payload) ? payload : null;
+      const baseMessage = extractErrorMessage(
+        payload,
+        `Request failed with status ${response.status}`
+      );
+      throw new VocoderAPIError({
+        message: errorPrefix ? `${errorPrefix}: ${baseMessage}` : baseMessage,
+        status: response.status,
+        payload,
+        limitError,
+        syncPolicyError
+      });
+    }
+    return payload;
+  }
+  /**
+   * Fetch project configuration from API
+   * Project is determined from the API key
+   */
+  async getProjectConfig() {
+    const data = await this.request("/api/cli/config", {}, "Failed to fetch project config");
+    return {
+      projectName: data.projectName,
+      organizationName: data.organizationName,
+      shortCode: data.shortCode,
+      sourceLocale: data.sourceLocale,
+      targetLocales: data.targetLocales,
+      targetBranches: data.targetBranches ?? ["main"],
+      primaryBranch: data.primaryBranch,
+      syncPolicy: {
+        blockingBranches: data.syncPolicy?.blockingBranches ?? [
+          "main",
+          "master"
+        ],
+        blockingMode: data.syncPolicy?.blockingMode ?? "required",
+        nonBlockingMode: data.syncPolicy?.nonBlockingMode ?? "best-effort",
+        defaultMaxWaitMs: data.syncPolicy?.defaultMaxWaitMs ?? 6e4
+      }
+    };
+  }
+  /**
+   * Submit strings for translation
+   * Project is determined from the API key
+   */
+  stableTextKey(text) {
+    let hash = 2166136261;
+    for (let i = 0; i < text.length; i++) {
+      hash ^= text.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return `SK_TEXT_${(hash >>> 0).toString(16).toUpperCase().padStart(8, "0")}`;
+  }
+  normalizeStringEntries(entries) {
+    if (entries.length === 0) {
+      return [];
+    }
+    const first = entries[0];
+    if (typeof first === "string") {
+      return entries.map((text) => ({
+        key: this.stableTextKey(text),
+        text
+      }));
+    }
+    return entries.map((entry, index) => ({
+      key: entry.key || this.stableTextKey(`${entry.text}:${index}`),
+      text: entry.text,
+      ...entry.context ? { context: entry.context } : {},
+      ...entry.formality ? { formality: entry.formality } : {},
+      ...entry.uiRole ? { uiRole: entry.uiRole } : {}
+    }));
+  }
+  async submitTranslation(branch, entries, targetLocales, options, repoIdentity) {
+    const stringEntries = this.normalizeStringEntries(entries);
+    const strings = stringEntries.map((entry) => entry.text);
+    const crypto = await import("crypto");
+    const sortedStrings = [...strings].sort();
+    const stringsHash = crypto.createHash("sha256").update(JSON.stringify(sortedStrings)).digest("hex");
+    return this.request(
+      "/api/cli/sync",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          branch,
+          stringEntries,
+          targetLocales,
+          ...options?.force ? {} : { stringsHash },
+          ...options?.requestedMode ? { requestedMode: options.requestedMode } : {},
+          ...typeof options?.requestedMaxWaitMs === "number" ? { requestedMaxWaitMs: options.requestedMaxWaitMs } : {},
+          ...options?.clientRunId ? { clientRunId: options.clientRunId } : {},
+          ...repoIdentity?.repoCanonical ? { repoCanonical: repoIdentity.repoCanonical } : {},
+          ...repoIdentity?.repoAppDir !== void 0 ? { repoAppDir: repoIdentity.repoAppDir } : {},
+          ...repoIdentity?.commitSha ? { commitSha: repoIdentity.commitSha } : {},
+          ...options?.appIndustry ? { appIndustry: options.appIndustry } : {}
+        })
+      },
+      "Translation submission failed"
+    );
+  }
+  /**
+   * Check translation status
+   */
+  async getTranslationStatus(batchId) {
+    return this.request(
+      `/api/cli/sync/status/${batchId}`,
+      {},
+      "Failed to check translation status"
+    );
+  }
+  async getTranslationSnapshot(params) {
+    const search = new URLSearchParams();
+    search.set("branch", params.branch);
+    for (const locale of params.targetLocales) {
+      search.append("targetLocale", locale);
+    }
+    return this.request(
+      `/api/cli/sync/snapshot?${search.toString()}`,
+      {},
+      "Failed to fetch translation snapshot"
+    );
+  }
+  /**
+   * Wait for translation to complete with polling
+   */
+  async waitForCompletion(batchId, timeout = 6e4, onProgress) {
+    const startTime = Date.now();
+    const pollInterval = 1e3;
+    while (Date.now() - startTime < timeout) {
+      const status = await this.getTranslationStatus(batchId);
+      if (onProgress) {
+        onProgress(status.progress);
+      }
+      if (status.status === "COMPLETED") {
+        if (!status.translations) {
+          throw new Error("Translation completed but no translations returned");
+        }
+        return {
+          translations: status.translations,
+          localeMetadata: status.localeMetadata
+        };
+      }
+      if (status.status === "FAILED") {
+        throw new Error(
+          `Translation failed: ${status.errorMessage || "Unknown error"}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Translation timeout after ${timeout}ms`);
+  }
+  async startInitSession(input) {
+    const response = await fetch(`${this.apiUrl}/api/cli/init/start`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(input)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to start init session (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async getInitSessionStatus(params) {
+    const response = await fetch(
+      `${this.apiUrl}/api/cli/init/status/${params.sessionId}`,
+      {
+        headers: {
+          Authorization: `Bearer ${params.pollToken}`
+        }
+      }
+    );
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to get init status (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── CLI Auth endpoints (no project API key needed) ──────────────────────────
+  /**
+   * Start a CLI auth session. Returns `{ sessionId, verificationUrl, expiresAt }`.
+   * `sessionId` is the raw poll token — keep it secret, used for polling.
+   */
+  async startCliAuthSession(callbackPort, repoCanonical) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...callbackPort != null ? { callbackPort } : {},
+        ...repoCanonical ? { repoCanonical } : {}
+      })
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to start auth session (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  /**
+   * Poll for CLI auth session completion.
+   * Returns `{ token }` on success, throws on failure/expiry.
+   * The server returns HTTP 202 while still pending.
+   */
+  async pollCliAuthSession(pollToken) {
+    const response = await fetch(
+      `${this.apiUrl}/api/cli/auth/session?session=${encodeURIComponent(pollToken)}`
+    );
+    const payload = await readPayload(response);
+    if (response.status === 202) {
+      return { status: "pending" };
+    }
+    if (response.status === 410) {
+      return {
+        status: "failed",
+        reason: extractErrorMessage(payload, "Auth session expired or failed")
+      };
+    }
+    if (!response.ok) {
+      return {
+        status: "failed",
+        reason: extractErrorMessage(
+          payload,
+          `Auth session error (${response.status})`
+        )
+      };
+    }
+    const result = payload;
+    if (!result.token) {
+      return { status: "failed", reason: "No token in response" };
+    }
+    return {
+      status: "complete",
+      token: result.token,
+      ...result.organizationId ? { organizationId: result.organizationId } : {}
+    };
+  }
+  /**
+   * Validate a CLI user token and return the authenticated user's info.
+   * Used by the CLI to verify stored credentials on startup.
+   */
+  async getCliUserInfo(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/me`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Token validation failed (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  /**
+   * Revoke the given CLI user token server-side.
+   */
+  async revokeCliToken(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/token`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    if (!response.ok) {
+      const payload = await readPayload(response);
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Token revocation failed (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+  }
+  // ── Workspaces ────────────────────────────────────────────────────────────────
+  async listWorkspaces(userToken, params) {
+    const url = new URL(`${this.apiUrl}/api/cli/workspaces`);
+    if (params?.repo) url.searchParams.set("repo", params.repo);
+    const response = await fetch(url.toString(), {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to list workspaces (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async listProjects(userToken, organizationId) {
+    const url = new URL(`${this.apiUrl}/api/cli/projects`);
+    url.searchParams.set("organizationId", organizationId);
+    const response = await fetch(url.toString(), {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to list projects (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    const result = payload;
+    return result.projects;
+  }
+  async regenerateProjectApiKey(userToken, projectId) {
+    const response = await fetch(
+      `${this.apiUrl}/api/cli/project/regenerate-key`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${userToken}`
+        },
+        body: JSON.stringify({ projectId })
+      }
+    );
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to regenerate API key (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── CLI GitHub endpoints ──────────────────────────────────────────────────────
+  async startCliGitHubInstall(userToken, params) {
+    const response = await fetch(
+      `${this.apiUrl}/api/cli/github/install/start`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${userToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(params)
+      }
+    );
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to start GitHub install (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  /**
+   * Start the "link existing installation" discovery flow.
+   * Unlike startCliGitHubOAuth, this requires no bearer token — the Vocoder
+   * account is created from the OAuth code in the callback.
+   */
+  async startCliGitHubLinkSession(sessionId, callbackPort) {
+    const response = await fetch(
+      `${this.apiUrl}/api/cli/github/oauth/link-start`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          sessionId,
+          ...callbackPort != null ? { callbackPort } : {}
+        })
+      }
+    );
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to start GitHub link session (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async startCliGitHubOAuth(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/oauth/start`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to start GitHub OAuth (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async getCliGitHubDiscovery(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/discovery`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to fetch GitHub discovery (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async claimCliGitHubInstallation(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/claim`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to claim GitHub installation (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── Locales ───────────────────────────────────────────────────────────────────
+  async listLocales(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/locales`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to list locales (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    const result = payload;
+    return result;
+  }
+  async listCompatibleLocales(userToken, sourceLocale) {
+    const url = `${this.apiUrl}/api/cli/locales/compatible?source=${encodeURIComponent(sourceLocale)}`;
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to list compatible locales (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    const result = payload;
+    return result.locales;
+  }
+  // ── Project creation ──────────────────────────────────────────────────────────
+  async createProject(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/projects`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${userToken}`
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to create project (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── Project lookup ────────────────────────────────────────────────────────────
+  /**
+   * Look up all project apps for a given repo. Returns info about exact matches,
+   * existing apps in other scopes, and whether a whole-repo app exists.
+   * No auth required.
+   */
+  async lookupProjectByRepo(params) {
+    try {
+      const response = await fetch(`${this.apiUrl}/api/cli/init/lookup`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          repo: params.repoCanonical,
+          appDir: params.appDir
+        })
+      });
+      if (!response.ok) {
+        return { exactMatch: null, existingApps: [], hasWholeRepoApp: false };
+      }
+      const data = await response.json();
+      return {
+        exactMatch: data.exactMatch ?? null,
+        existingApps: data.existingApps ?? [],
+        hasWholeRepoApp: data.hasWholeRepoApp ?? false
+      };
+    } catch {
+      return { exactMatch: null, existingApps: [], hasWholeRepoApp: false };
+    }
+  }
+  /**
+   * Add a new ProjectApp to an existing project (monorepo: new app directory).
+   * Does not check plan limits — no new project is created.
+   */
+  async createProjectApp(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/project/apps`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${userToken}`
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(
+          payload,
+          `Failed to create project app (${response.status})`
+        ),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+};
+
 // src/utils/detect-local.ts
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
@@ -43679,6 +44360,48 @@ function getPackagesToInstall(detection) {
   return { devPackages, runtimePackages };
 }
 
+// src/utils/auth-store.ts
+import { mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2 } from "path";
+function getAuthFilePath() {
+  return join2(homedir(), ".config", "vocoder", "auth.json");
+}
+function readAuthData() {
+  const filePath = getAuthFilePath();
+  try {
+    const raw = readFileSync2(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    const data = parsed;
+    if (typeof data.token !== "string" || typeof data.userId !== "string" || typeof data.email !== "string" || typeof data.createdAt !== "string") {
+      return null;
+    }
+    return {
+      token: data.token,
+      userId: data.userId,
+      email: data.email,
+      name: typeof data.name === "string" ? data.name : null,
+      createdAt: data.createdAt
+    };
+  } catch {
+    return null;
+  }
+}
+function writeAuthData(data) {
+  const filePath = getAuthFilePath();
+  const dir = dirname(filePath);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function clearAuthData() {
+  const filePath = getAuthFilePath();
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+}
+
 // src/utils/setup-snippets.ts
 function getSetupSnippets(params) {
   const { framework, ecosystem, sourceLocale } = params;
@@ -43840,28 +44563,28 @@ import { T } from '@vocoder/vue';
 // ../extractor/src/config.ts
 var import_parser = __toESM(require_lib());
 var import_traverse = __toESM(require_lib8());
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 var traverse = import_traverse.default.default || import_traverse.default;
 function loadVocoderConfig(cwd) {
   const candidates = [
-    join2(cwd, "vocoder.config.ts"),
-    join2(cwd, "vocoder.config.js"),
-    join2(cwd, "vocoder.config.mjs"),
-    join2(cwd, "vocoder.config.cjs")
+    join3(cwd, "vocoder.config.ts"),
+    join3(cwd, "vocoder.config.js"),
+    join3(cwd, "vocoder.config.mjs"),
+    join3(cwd, "vocoder.config.cjs")
   ];
   for (const configPath of candidates) {
     if (!existsSync2(configPath)) continue;
     try {
-      const code = readFileSync2(configPath, "utf-8");
+      const code = readFileSync3(configPath, "utf-8");
       return parseConfigFromSource(code);
     } catch {
     }
   }
-  const jsonPath = join2(cwd, "vocoder.config.json");
+  const jsonPath = join3(cwd, "vocoder.config.json");
   if (existsSync2(jsonPath)) {
     try {
-      return JSON.parse(readFileSync2(jsonPath, "utf-8"));
+      return JSON.parse(readFileSync3(jsonPath, "utf-8"));
     } catch {
       return null;
     }
@@ -43909,6 +44632,12 @@ function extractFromObject(obj) {
     if (key === "localesPath" && prop.value.type === "StringLiteral") {
       config.localesPath = prop.value.value;
     }
+    if (key === "appIndustry" && prop.value.type === "StringLiteral") {
+      config.appIndustry = prop.value.value;
+    }
+    if (key === "formality" && prop.value.type === "StringLiteral") {
+      config.formality = prop.value.value;
+    }
   }
   return config;
 }
@@ -43916,7 +44645,7 @@ function extractFromObject(obj) {
 // ../extractor/src/index.ts
 var import_parser2 = __toESM(require_lib());
 var import_traverse2 = __toESM(require_lib8());
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { relative as pathRelative } from "path";
 
 // ../../node_modules/.pnpm/minimatch@9.0.5/node_modules/minimatch/dist/esm/index.js
@@ -50393,249 +51122,324 @@ var StringExtractor = class {
     const sortedFiles = Array.from(allFiles).sort();
     for (const file of sortedFiles) {
       try {
-        const strings = await this.extractFromFile(file, projectRoot);
+        const code = readFileSync4(file, "utf-8");
+        const relPath = pathRelative(projectRoot, file).split("\\").join("/");
+        const strings = _extractFromContent(relPath, code);
         allStrings.push(...strings);
       } catch (error) {
         console.warn(`Warning: Failed to extract from ${file}:`, error);
       }
     }
-    return this.deduplicateStrings(allStrings);
+    return deduplicateStrings(allStrings);
   }
-  async extractFromFile(filePath, projectRoot) {
-    const code = readFileSync3(filePath, "utf-8");
-    const strings = [];
-    const relativeFilePath = pathRelative(projectRoot, filePath).split("\\").join("/");
-    try {
-      const ast = (0, import_parser2.parse)(code, {
-        sourceType: "module",
-        plugins: ["jsx", "typescript"]
-      });
-      const vocoderImports = /* @__PURE__ */ new Map();
-      const tFunctionNames = /* @__PURE__ */ new Set();
-      traverse2(ast, {
-        ImportDeclaration: (path2) => {
-          const source = path2.node.source.value;
-          if (source === "@vocoder/react") {
-            path2.node.specifiers.forEach((spec) => {
-              if (spec.type === "ImportSpecifier") {
-                const imported = spec.imported.type === "Identifier" ? spec.imported.name : null;
-                const local = spec.local.name;
-                if (imported === "T") {
-                  vocoderImports.set(local, "T");
-                }
-                if (imported === "t") {
-                  tFunctionNames.add(local);
-                }
+};
+function propNameToUiRole(propName) {
+  switch (propName) {
+    case "placeholder":
+      return "input_placeholder";
+    case "aria-label":
+    case "aria-description":
+    case "label":
+      return "input_label";
+    case "alt":
+      return "image_alt";
+    case "title":
+      return "tooltip";
+    default:
+      return "unknown";
+  }
+}
+function elementNameToUiRole(name) {
+  if (!name) return "unknown";
+  switch (name.toLowerCase()) {
+    case "button":
+      return "button_label";
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return "heading";
+    case "label":
+      return "input_label";
+    case "th":
+      return "table_header";
+    case "option":
+      return "option_label";
+    case "title":
+      return "page_title";
+    case "p":
+    case "li":
+    case "dd":
+      return "body_text";
+    // Custom component name heuristics
+    default: {
+      const lower = name.toLowerCase();
+      if (/button|btn|submit|cta/.test(lower)) return "button_label";
+      if (/heading|headline/.test(lower)) return "heading";
+      if (/label/.test(lower)) return "input_label";
+      if (/tooltip|hint|popover/.test(lower)) return "tooltip";
+      if (/badge|chip|tag|pill/.test(lower)) return "badge";
+      if (/toast|snackbar|notification/.test(lower)) return "toast";
+      if (/navitem|menuitem/.test(lower)) return "nav_item";
+      return "unknown";
+    }
+  }
+}
+function detectUiRole(path2) {
+  const parent = path2.parent;
+  if (!parent) return "unknown";
+  if (parent.type === "JSXExpressionContainer") {
+    const attrNode = path2.parentPath?.parent;
+    if (attrNode?.type === "JSXAttribute") {
+      const propName = attrNode.name?.type === "JSXNamespacedName" ? `${attrNode.name.namespace.name}-${attrNode.name.name.name}` : attrNode.name?.name ?? "";
+      return propNameToUiRole(propName);
+    }
+  }
+  if (parent.type === "JSXElement") {
+    const opening = parent.openingElement;
+    const tagName = opening?.name?.type === "JSXMemberExpression" ? "unknown" : opening?.name?.name ?? "";
+    return elementNameToUiRole(tagName);
+  }
+  return "unknown";
+}
+function _extractFromContent(filePath, content) {
+  const strings = [];
+  try {
+    const ast = (0, import_parser2.parse)(content, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"]
+    });
+    const vocoderImports = /* @__PURE__ */ new Map();
+    const tFunctionNames = /* @__PURE__ */ new Set();
+    traverse2(ast, {
+      ImportDeclaration: (path2) => {
+        const source = path2.node.source.value;
+        if (source === "@vocoder/react") {
+          path2.node.specifiers.forEach((spec) => {
+            if (spec.type === "ImportSpecifier") {
+              const imported = spec.imported.type === "Identifier" ? spec.imported.name : null;
+              const local = spec.local.name;
+              if (imported === "T") {
+                vocoderImports.set(local, "T");
               }
-            });
-          }
-        },
-        VariableDeclarator: (path2) => {
-          const init = path2.node.init;
-          if (init && init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "useVocoder" && path2.node.id.type === "ObjectPattern") {
-            path2.node.id.properties.forEach((prop) => {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "t") {
-                const localName = prop.value.type === "Identifier" ? prop.value.name : "t";
-                tFunctionNames.add(localName);
+              if (imported === "t") {
+                tFunctionNames.add(local);
               }
-            });
-          }
-        },
-        CallExpression: (path2) => {
-          const callee = path2.node.callee;
-          const isTFunction = callee.type === "Identifier" && tFunctionNames.has(callee.name);
-          if (!isTFunction) return;
-          const firstArg = path2.node.arguments[0];
-          if (!firstArg) return;
-          let text = null;
-          if (firstArg.type === "StringLiteral") {
-            text = firstArg.value;
-          } else if (firstArg.type === "TemplateLiteral") {
-            text = this.extractTemplateText(firstArg);
-          }
-          if (!text || text.trim().length === 0) return;
-          const optionsArg = path2.node.arguments[2];
-          let context;
-          let formality;
-          let explicitKey;
-          if (optionsArg && optionsArg.type === "ObjectExpression") {
-            optionsArg.properties.forEach((prop) => {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
-                if (prop.key.name === "context" && prop.value.type === "StringLiteral") {
-                  context = prop.value.value;
-                }
-                if (prop.key.name === "formality" && prop.value.type === "StringLiteral") {
-                  formality = prop.value.value;
-                }
-                if (prop.key.name === "id" && prop.value.type === "StringLiteral") {
-                  explicitKey = prop.value.value.trim();
-                }
+            }
+          });
+        }
+      },
+      VariableDeclarator: (path2) => {
+        const init = path2.node.init;
+        if (init && init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "useVocoder" && path2.node.id.type === "ObjectPattern") {
+          path2.node.id.properties.forEach((prop) => {
+            if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "t") {
+              const localName = prop.value.type === "Identifier" ? prop.value.name : "t";
+              tFunctionNames.add(localName);
+            }
+          });
+        }
+      },
+      CallExpression: (path2) => {
+        const callee = path2.node.callee;
+        const isTFunction = callee.type === "Identifier" && tFunctionNames.has(callee.name);
+        if (!isTFunction) return;
+        const firstArg = path2.node.arguments[0];
+        if (!firstArg) return;
+        let text = null;
+        if (firstArg.type === "StringLiteral") {
+          text = firstArg.value;
+        } else if (firstArg.type === "TemplateLiteral") {
+          text = extractTemplateText(firstArg);
+        }
+        if (!text || text.trim().length === 0) return;
+        const optionsArg = path2.node.arguments[2];
+        let context;
+        let formality;
+        let explicitKey;
+        if (optionsArg && optionsArg.type === "ObjectExpression") {
+          optionsArg.properties.forEach((prop) => {
+            if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
+              if (prop.key.name === "context" && prop.value.type === "StringLiteral") {
+                context = prop.value.value;
               }
-            });
-          }
-          const line = path2.node.loc?.start.line || 0;
-          const key = explicitKey && explicitKey.length > 0 ? explicitKey : generateMessageHash(text.trim(), context);
-          strings.push({
-            key,
-            text: text.trim(),
-            file: filePath,
-            line,
-            context,
-            formality
+              if (prop.key.name === "formality" && prop.value.type === "StringLiteral") {
+                formality = prop.value.value;
+              }
+              if (prop.key.name === "id" && prop.value.type === "StringLiteral") {
+                explicitKey = prop.value.value.trim();
+              }
+            }
           });
-        },
-        JSXElement: (path2) => {
-          const opening = path2.node.openingElement;
-          const tagName = opening.name.type === "JSXIdentifier" ? opening.name.name : null;
-          if (!tagName) return;
-          const isTranslationComponent = vocoderImports.has(tagName);
-          if (!isTranslationComponent) return;
-          const msgAttribute = this.getStringAttribute(opening.attributes, "message");
-          let text = null;
-          if (msgAttribute) {
-            text = msgAttribute;
+        }
+        const line = path2.node.loc?.start.line || 0;
+        const key = explicitKey && explicitKey.length > 0 ? explicitKey : generateMessageHash(text.trim(), context);
+        const uiRole = detectUiRole(path2);
+        strings.push({
+          key,
+          text: text.trim(),
+          file: filePath,
+          line,
+          context,
+          formality,
+          uiRole: uiRole !== "unknown" ? uiRole : void 0
+        });
+      },
+      JSXElement: (path2) => {
+        const opening = path2.node.openingElement;
+        const tagName = opening.name.type === "JSXIdentifier" ? opening.name.name : null;
+        if (!tagName) return;
+        const isTranslationComponent = vocoderImports.has(tagName);
+        if (!isTranslationComponent) return;
+        const msgAttribute = getStringAttribute(opening.attributes, "message");
+        let text = null;
+        if (msgAttribute) {
+          text = msgAttribute;
+        } else {
+          const pluralSelectICU = extractPluralSelectICU(opening.attributes);
+          if (pluralSelectICU) {
+            text = pluralSelectICU;
           } else {
-            const pluralSelectICU = this.extractPluralSelectICU(
-              opening.attributes
-            );
-            if (pluralSelectICU) {
-              text = pluralSelectICU;
-            } else {
-              text = extractTextContentFromNodes(path2.node.children, { count: 0 });
-            }
+            text = extractTextContentFromNodes(path2.node.children, { count: 0 });
           }
-          if (!text || text.trim().length === 0) return;
-          const id = this.getStringAttribute(opening.attributes, "id");
-          const context = this.getStringAttribute(
-            opening.attributes,
-            "context"
-          );
-          const formality = this.getStringAttribute(
-            opening.attributes,
-            "formality"
-          );
-          const line = path2.node.loc?.start.line || 0;
-          const key = id && id.trim().length > 0 ? id.trim() : generateMessageHash(text.trim(), context);
-          strings.push({
-            key,
-            text: text.trim(),
-            file: filePath,
-            line,
-            context,
-            formality
-          });
         }
-      });
-    } catch (error) {
-      throw new Error(
-        `Failed to parse ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-    return strings;
-  }
-  extractPluralSelectICU(attributes) {
-    const pluralProps = {};
-    const selectProps = {};
-    let otherValue;
-    let hasPlural = false;
-    let hasSelect = false;
-    let isOrdinal = false;
-    let hasGender = false;
-    for (const attr of attributes) {
-      if (attr.type !== "JSXAttribute") continue;
-      const name = attr.name.name;
-      if (name === "ordinal") {
-        isOrdinal = true;
-        continue;
-      }
-      if (name === "gender") {
-        hasGender = true;
-        continue;
-      }
-      const value = attr.value?.type === "StringLiteral" ? attr.value.value : null;
-      if (!value) continue;
-      if (PLURAL_CLDR.has(name) || /^_\d+$/.test(name)) {
-        pluralProps[name] = value;
-        hasPlural = true;
-      } else if (name === "other") {
-        otherValue = value;
-      } else if (/^_[a-zA-Z]/.test(name)) {
-        selectProps[name] = value;
-        hasSelect = true;
+        if (!text || text.trim().length === 0) return;
+        const id = getStringAttribute(opening.attributes, "id");
+        const context = getStringAttribute(opening.attributes, "context");
+        const formality = getStringAttribute(
+          opening.attributes,
+          "formality"
+        );
+        const line = path2.node.loc?.start.line || 0;
+        const key = id && id.trim().length > 0 ? id.trim() : generateMessageHash(text.trim(), context);
+        const uiRole = detectUiRole(path2);
+        strings.push({
+          key,
+          text: text.trim(),
+          file: filePath,
+          line,
+          context,
+          formality,
+          uiRole: uiRole !== "unknown" ? uiRole : void 0
+        });
       }
+    });
+  } catch (error) {
+    throw new Error(
+      `Failed to parse ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+  return strings;
+}
+function extractPluralSelectICU(attributes) {
+  const pluralProps = {};
+  const selectProps = {};
+  let otherValue;
+  let hasPlural = false;
+  let hasSelect = false;
+  let isOrdinal = false;
+  let hasGender = false;
+  for (const attr of attributes) {
+    if (attr.type !== "JSXAttribute") continue;
+    const name = attr.name.name;
+    if (name === "ordinal") {
+      isOrdinal = true;
+      continue;
     }
-    if (isOrdinal) {
-      const ordinalICU = "{count, selectordinal, other {#}}";
-      if (hasGender) {
-        return `{gender, select, masculine {${ordinalICU}} feminine {${ordinalICU}} other {${ordinalICU}}}`;
-      }
-      return ordinalICU;
+    if (name === "gender") {
+      hasGender = true;
+      continue;
     }
-    if (!hasPlural && !hasSelect) return null;
-    if (hasPlural) {
-      if (otherValue !== void 0) pluralProps.other = otherValue;
-      return buildPluralICU(pluralProps, false);
+    const value = attr.value?.type === "StringLiteral" ? attr.value.value : null;
+    if (!value) continue;
+    if (PLURAL_CLDR.has(name) || /^_\d+$/.test(name)) {
+      pluralProps[name] = value;
+      hasPlural = true;
+    } else if (name === "other") {
+      otherValue = value;
+    } else if (/^_[a-zA-Z]/.test(name)) {
+      selectProps[name] = value;
+      hasSelect = true;
     }
-    if (hasSelect) {
-      if (otherValue !== void 0) selectProps.other = otherValue;
-      return buildSelectICU(selectProps);
+  }
+  if (isOrdinal) {
+    const ordinalICU = "{count, selectordinal, other {#}}";
+    if (hasGender) {
+      return `{gender, select, masculine {${ordinalICU}} feminine {${ordinalICU}} other {${ordinalICU}}}`;
     }
-    return null;
+    return ordinalICU;
   }
-  extractTemplateText(node) {
-    let text = "";
-    for (let i = 0; i < node.quasis.length; i++) {
-      const quasi = node.quasis[i];
-      text += quasi.value.raw;
-      if (i < node.expressions.length) {
-        const expr = node.expressions[i];
-        if (expr.type === "Identifier") {
-          text += `{${expr.name}}`;
-        } else {
-          text += "{value}";
-        }
+  if (!hasPlural && !hasSelect) return null;
+  if (hasPlural) {
+    if (otherValue !== void 0) pluralProps.other = otherValue;
+    return buildPluralICU(pluralProps, false);
+  }
+  if (hasSelect) {
+    if (otherValue !== void 0) selectProps.other = otherValue;
+    return buildSelectICU(selectProps);
+  }
+  return null;
+}
+function extractTemplateText(node) {
+  let text = "";
+  for (let i = 0; i < node.quasis.length; i++) {
+    const quasi = node.quasis[i];
+    text += quasi.value.raw;
+    if (i < node.expressions.length) {
+      const expr = node.expressions[i];
+      if (expr.type === "Identifier") {
+        text += `{${expr.name}}`;
+      } else {
+        text += "{value}";
       }
     }
-    return text;
   }
-  getStringAttribute(attributes, name) {
-    const attr = attributes.find(
-      (a) => a.type === "JSXAttribute" && a.name.name === name
-    );
-    if (!attr || !attr.value) return void 0;
-    if (attr.value.type === "StringLiteral") {
-      return attr.value.value;
+  return text;
+}
+function getStringAttribute(attributes, name) {
+  const attr = attributes.find(
+    (a) => a.type === "JSXAttribute" && a.name.name === name
+  );
+  if (!attr || !attr.value) return void 0;
+  if (attr.value.type === "StringLiteral") {
+    return attr.value.value;
+  }
+  if (attr.value.type === "JSXExpressionContainer") {
+    const expr = attr.value.expression;
+    if (expr.type === "TemplateLiteral") {
+      return extractTemplateText(expr);
     }
-    if (attr.value.type === "JSXExpressionContainer") {
-      const expr = attr.value.expression;
-      if (expr.type === "TemplateLiteral") {
-        return this.extractTemplateText(expr);
-      }
-      if (expr.type === "StringLiteral") {
-        return expr.value;
-      }
+    if (expr.type === "StringLiteral") {
+      return expr.value;
     }
-    return void 0;
   }
-  deduplicateStrings(strings) {
-    const seen = /* @__PURE__ */ new Set();
-    const unique = [];
-    for (const str of strings) {
-      if (!seen.has(str.key)) {
-        seen.add(str.key);
-        unique.push(str);
-      }
+  return void 0;
+}
+function deduplicateStrings(strings) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const str of strings) {
+    if (!seen.has(str.key)) {
+      seen.add(str.key);
+      unique.push(str);
     }
-    return unique;
   }
-};
+  return unique;
+}
 
 export {
+  VocoderAPIError,
+  VocoderAPI,
   detectLocalEcosystem,
   buildInstallCommand,
   getPackagesToInstall,
+  readAuthData,
+  writeAuthData,
+  clearAuthData,
   getSetupSnippets,
   loadVocoderConfig,
   StringExtractor
 };
-//# sourceMappingURL=chunk-IZN5HVYD.mjs.map
+//# sourceMappingURL=chunk-XF3KGGYQ.mjs.map