polycast-cli 0.1.0

package/dist/commands.js

@@ -0,0 +1,612 @@
+import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { CliError, confirm, promptHidden, isCI } from "./util.js";
+import { S, c, g, bold, dim, green, red, yellow, accent, header, section, kv, bar, pctLabel, flag, table, box, spin, success, note, relativeTime, } from "./ui.js";
+import { DEFAULT_API, DEFAULT_EDGE, findConfig, requireConfig, writeConfig, ensureGitignored, stateDir, } from "./config.js";
+import { admin, edge, project, requireAdminToken } from "./api.js";
+import { storeToken, loadToken, clearToken } from "./keychain.js";
+import { parseCatalog, mergeTranslations, writeCatalog, serializeCatalog, addMissingKeys } from "./xcstrings.js";
+import { scanSwiftSources } from "./scan.js";
+const apiOf = (config) => config?.endpoint ?? DEFAULT_API;
+const edgeOf = (config) => config?.edgeEndpoint ?? DEFAULT_EDGE;
+/** Resolve the project id for admin commands from polycast.json's key. */
+async function resolveProject() {
+    const { config, dir } = requireConfig();
+    const token = requireAdminToken();
+    const { projectId } = await admin.resolveKey(apiOf(config), token, config.projectKey);
+    return { config, dir, token, projectId };
+}
+// ---- login / logout ----
+export async function login(flags) {
+    const endpoint = flags.endpoint ?? findConfig()?.config.endpoint ?? DEFAULT_API;
+    let token;
+    if (flags.token || isCI()) {
+        // Headless: paste a personal access token (pcat_) or legacy admin token.
+        token = await promptHidden("Personal access token (pcat_…): ");
+        if (!token)
+            throw new CliError("no token entered", 2);
+    }
+    else {
+        token = await browserLogin(endpoint, flags.org);
+    }
+    const sp = spin("validating token");
+    await admin.listProjects(endpoint, token); // validates against the API
+    storeToken(token);
+    sp.succeed(`logged in — token stored in ${process.platform === "darwin" ? "your keychain" : "~/.config/polycast/token"}`);
+}
+/** Browser flow: localhost listener + {endpoint}/cli/authorize (Clerk
+ * sign-in page) which mints a PAT and redirects back with it. Falls back
+ * to paste when the server has no Clerk configured. */
+async function browserLogin(endpoint, org) {
+    const { createServer } = await import("node:http");
+    const { exec } = await import("node:child_process");
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", "http://127.0.0.1");
+            const token = url.searchParams.get("token");
+            if (url.pathname === "/callback" && token) {
+                res.writeHead(200, { "content-type": "text/html" });
+                res.end("<h3>Logged in — you can close this tab and return to the terminal.</h3>");
+                server.close();
+                resolve(token);
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        server.listen(0, "127.0.0.1", () => {
+            const port = server.address().port;
+            const authorize = `${endpoint}/cli/authorize?port=${port}${org ? `&org=${org}` : ""}`;
+            console.log(`Opening ${authorize}`);
+            console.log(dim("(if the server has no Clerk configured, rerun with --token)"));
+            const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+            exec(`${opener} ${JSON.stringify(authorize)}`);
+            setTimeout(() => { server.close(); reject(new CliError("login timed out after 5 minutes")); }, 300_000).unref();
+        });
+    });
+}
+export async function whoami(flags) {
+    const endpoint = flags.endpoint ?? findConfig()?.config.endpoint ?? DEFAULT_API;
+    const token = requireAdminToken();
+    const res = await fetch(`${endpoint}/v1/admin/orgs/me`, {
+        headers: { authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        throw new CliError("token invalid — run `polycast login`");
+    const me = await res.json();
+    if (flags.json) {
+        console.log(JSON.stringify(me, null, 2));
+        return;
+    }
+    header("whoami");
+    for (const org of me.orgs) {
+        console.log(`  ${S.bullet} ${bold(org.name)}  ${accent(org.role)} ${dim(`· ${org.plan} plan · ${org.id}`)}`);
+    }
+    if (me.orgs.length === 0)
+        console.log(`  ${S.warn} ${yellow("no org memberships found")}`);
+    console.log();
+}
+export async function logout() {
+    clearToken();
+    console.log("logged out");
+}
+// ---- init ----
+function detectCatalog(cwd) {
+    const hits = [];
+    const walk = (dir, depth) => {
+        if (depth > 4)
+            return;
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.startsWith(".") || ["node_modules", "Pods", "build", "DerivedData", ".build"].includes(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full, depth + 1);
+            else if (entry.name.endsWith(".xcstrings"))
+                hits.push(full);
+        }
+    };
+    walk(cwd, 0);
+    if (hits.length === 1)
+        return path.relative(cwd, hits[0]);
+    if (hits.length > 1) {
+        const preferred = hits.find((h) => path.basename(h) === "Localizable.xcstrings");
+        return preferred ? path.relative(cwd, preferred) : null;
+    }
+    return null;
+}
+function detectProjectName(cwd) {
+    const xcodeproj = readdirSync(cwd).find((f) => f.endsWith(".xcodeproj"));
+    if (xcodeproj)
+        return xcodeproj.replace(/\.xcodeproj$/, "");
+    const pkg = path.join(cwd, "Package.swift");
+    if (existsSync(pkg)) {
+        const m = /name:\s*"([^"]+)"/.exec(readFileSync(pkg, "utf8"));
+        if (m)
+            return m[1];
+    }
+    return path.basename(cwd);
+}
+export async function init(flags) {
+    const cwd = process.cwd();
+    const endpoint = flags.endpoint ?? DEFAULT_API;
+    const existing = findConfig(cwd);
+    if (existing) {
+        // Idempotent: verify rather than recreate.
+        const token = loadToken();
+        console.log(`polycast.json found (project key ${existing.config.projectKey.slice(0, 12)}…)`);
+        if (token) {
+            const resolved = await admin.resolveKey(apiOf(existing.config), token, existing.config.projectKey);
+            console.log(`  ${S.ok} verified: ${bold(resolved.name)} ${dim(`(${resolved.projectId})`)}`);
+        }
+        else {
+            console.log(dim("run `polycast login` + `polycast doctor` for a full verification"));
+        }
+        return;
+    }
+    const token = requireAdminToken();
+    const catalogPath = flags.catalog ?? detectCatalog(cwd);
+    if (!catalogPath) {
+        throw new CliError("could not find a unique .xcstrings catalog — pass --catalog <path>", 2);
+    }
+    parseCatalog(path.resolve(cwd, catalogPath)); // fail fast if unparseable
+    const name = flags.name ?? detectProjectName(cwd);
+    const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63) || "app";
+    if (!(await confirm(`Create Polycast project "${name}" (slug: ${slug})?`, flags.yes))) {
+        throw new CliError("aborted", 2);
+    }
+    const created = await admin.createProject(endpoint, token, { name, slug });
+    const key = await admin.createKey(endpoint, token, created.id, "pc_live_");
+    const config = {
+        endpoint, edgeEndpoint: DEFAULT_EDGE, projectKey: key.key, catalogPath,
+    };
+    writeConfig(cwd, config);
+    ensureGitignored(cwd);
+    success(`project "${name}" created — polycast.json written`);
+    console.log(`  ${bold("Two integration touches:")}\n`);
+    console.log(`1. Add the build plugin to your app target (Package.swift):
+
+     .target(
+         name: "${name}",
+         plugins: [.plugin(name: "PolycastBuildPlugin", package: "polycast-swift")]
+     )
+
+2. Start Polycast in your App init:
+
+     import Polycast
+
+     init() {
+         Polycast.configure(endpoint: URL(string: "${edgeOf(config)}")!)
+         Polycast.start(key: "${key.key}")
+     }
+
+Then: build once (the plugin pushes your strings), \`polycast langs add <locales>\`, \`polycast publish --wait\`.`);
+}
+// ---- langs ----
+/** App Store locales for `langs add all`. */
+const APP_STORE_LOCALES = [
+    "ar", "ca", "zh-Hans", "zh-Hant", "hr", "cs", "da", "nl", "en-AU", "en-CA",
+    "en-GB", "fi", "fr", "fr-CA", "de", "el", "he", "hi", "hu", "id", "it",
+    "ja", "ko", "ms", "no", "pl", "pt-BR", "pt-PT", "ro", "ru", "sk", "es",
+    "es-419", "sv", "th", "tr", "uk", "vi",
+];
+function nativeName(locale) {
+    try {
+        const name = new Intl.DisplayNames([locale], { type: "language" }).of(locale);
+        if (name && name !== locale)
+            return name[0].toUpperCase() + name.slice(1);
+    }
+    catch { /* fall through */ }
+    return locale;
+}
+export async function langs(args, flags) {
+    const { config, token, projectId } = await resolveProject();
+    const [sub, ...rest] = args;
+    if (!sub) {
+        const status = await admin.status(apiOf(config), token, projectId);
+        if (flags.json) {
+            console.log(JSON.stringify(status.locales, null, 2));
+            return;
+        }
+        header(status.project.name, `${status.totalStrings} source strings ${g.sep} ${status.locales.filter((l) => l.enabled).length} languages`);
+        console.log(table(["", "locale", "", "coverage", "", "drafts", "review"], status.locales.filter((l) => l.enabled).map((l) => [
+            flag(l.locale),
+            c.accent2(l.locale),
+            c.muted(l.nativeName),
+            bar(l.coveragePct),
+            pctLabel(l.coveragePct),
+            l.drafts > 0 ? c.danger(String(l.drafts)) : c.muted("0"),
+            l.needsReview > 0 ? c.negative(String(l.needsReview)) : c.muted("0"),
+        ])));
+        console.log();
+        return;
+    }
+    if (sub === "add") {
+        const ids = rest[0] === "all" ? APP_STORE_LOCALES : rest;
+        if (ids.length === 0)
+            throw new CliError("usage: polycast langs add <locale...>|all", 2);
+        const status = await admin.status(apiOf(config), token, projectId);
+        const newOnes = ids.filter((id) => !status.locales.some((l) => l.locale === id && l.enabled));
+        const willDraft = newOnes.length * status.totalStrings;
+        if (newOnes.length === 0) {
+            console.log("all requested languages already enabled");
+            return;
+        }
+        if (!(await confirm(`Enable ${newOnes.join(", ")} — ${willDraft} string(s) will be AI-drafted. Continue?`, flags.yes))) {
+            throw new CliError("aborted", 2);
+        }
+        const sp = spin(`enabling ${newOnes.map((l) => `${flag(l)} ${l}`).join("  ")}`);
+        const result = await admin.putLocales(apiOf(config), token, projectId, {
+            locales: ids.map((id) => ({ id, nativeName: nativeName(id), enabled: true })),
+        });
+        sp.succeed(`enabled ${bold(String(ids.length))} language(s) — ${accent(String(result.draftJobsEnqueued))} draft job(s) queued`);
+        note("drafting runs in the background — `polycast publish --wait` when you're ready");
+        return;
+    }
+    if (sub === "remove") {
+        if (rest.length === 0)
+            throw new CliError("usage: polycast langs remove <locale...>", 2);
+        await admin.putLocales(apiOf(config), token, projectId, {
+            locales: rest.map((id) => ({ id, nativeName: nativeName(id), enabled: false })),
+        });
+        console.log(`disabled: ${rest.join(", ")} (bundles stop being served on next publish)`);
+        return;
+    }
+    throw new CliError(`unknown subcommand: langs ${sub}`, 2);
+}
+// ---- push ----
+export async function push(flags) {
+    const { config, dir } = requireConfig();
+    const catalogFile = path.resolve(dir, config.catalogPath);
+    // Zero-config capture: PText / Polycast.string literals in Swift
+    // sources are merged into the catalog automatically — write code,
+    // run push, done.
+    const scanned = scanSwiftSources(dir, config.scanCalls ?? []);
+    {
+        const { raw } = parseCatalog(catalogFile);
+        const added = addMissingKeys(raw, scanned);
+        if (added.length > 0) {
+            writeCatalog(catalogFile, raw);
+            console.log(`\n  ${S.ok}  captured ${bold(String(added.length))} new string(s) from source ${c.muted(`→ ${config.catalogPath}`)}`);
+            for (const key of added.slice(0, 8))
+                console.log(`      ${c.positive("+")}  ${c.text(key)}`);
+            if (added.length > 8)
+                console.log(`      ${c.muted(`… and ${added.length - 8} more`)}`);
+        }
+    }
+    const { sourceLocale, strings } = parseCatalog(catalogFile);
+    console.log(`\n  ${S.diamond} ${c.text(`${strings.length} strings`)} ${c.muted(`(catalog + source scan) from ${config.catalogPath}`)}`);
+    const stateFile = path.join(stateDir(dir), "last-push.json");
+    const previous = existsSync(stateFile)
+        ? (JSON.parse(readFileSync(stateFile, "utf8")).digests ?? {})
+        : {};
+    const changedOrNew = strings.filter((s) => previous[s.key] !== s.digest);
+    const newCount = changedOrNew.filter((s) => !(s.key in previous)).length;
+    console.log(`  ${green(`+${newCount} new`)} ${S.dot} ${yellow(`~${changedOrNew.length - newCount} changed`)} ${S.dot} ${dim(`${strings.length - changedOrNew.length} unchanged`)}\n`);
+    if (changedOrNew.length === 0)
+        return;
+    const sp = spin("pushing source strings");
+    const result = await project.pushStrings(apiOf(config), config.projectKey, {
+        schemaVersion: 1,
+        projectKey: config.projectKey,
+        sourceLocale,
+        strings: changedOrNew.map(({ key, comment, pluralShape, digest }) => ({
+            key, ...(comment !== undefined ? { comment } : {}),
+            ...(pluralShape ? { pluralShape } : {}), digest,
+        })),
+    });
+    const digests = { ...previous };
+    for (const s of strings)
+        digests[s.key] = s.digest;
+    writeFileSync(stateFile, JSON.stringify({ digests }, null, 2));
+    sp.succeed(`pushed — ${accent(String(result.draftJobsEnqueued))} draft job(s) queued across enabled languages`);
+}
+// ---- pull ----
+export async function pull(flags) {
+    const { config, dir } = requireConfig();
+    const catalogFile = path.resolve(dir, config.catalogPath);
+    const { raw } = parseCatalog(catalogFile);
+    const before = serializeCatalog(raw);
+    const manifest = await edge.manifest(edgeOf(config), config.projectKey);
+    const wanted = flags.locales?.split(",").map((s) => s.trim()).filter(Boolean);
+    const locales = manifest.locales.map((l) => l.id)
+        .filter((id) => !wanted || wanted.includes(id));
+    let changed = 0;
+    for (const locale of locales) {
+        const bundle = await edge.bundle(edgeOf(config), config.projectKey, locale);
+        changed += mergeTranslations(raw, locale, bundle.strings);
+    }
+    const after = serializeCatalog(raw);
+    if (flags.check) {
+        if (after !== before) {
+            console.error(`  ${S.fail} ${red(`catalog is stale — pulling would change ${bold(String(changed))} value(s) across ${locales.length} language(s)`)}`);
+            process.exit(1);
+        }
+        success("catalog fallbacks are up to date");
+        return;
+    }
+    if (after === before) {
+        note("catalog already up to date");
+        return;
+    }
+    writeCatalog(catalogFile, raw);
+    success(`merged ${locales.map(flag).join(" ")}  ${locales.join(", ")} — ${changed} value(s) updated`);
+}
+// ---- publish ----
+export async function publish(args, flags) {
+    const { config, token, projectId } = await resolveProject();
+    const api = apiOf(config);
+    let targets = args;
+    if (flags.wait) {
+        const sp = spin("waiting for drafting to finish");
+        const deadline = Date.now() + 10 * 60_000;
+        for (;;) {
+            const status = await admin.status(api, token, projectId);
+            const pending = status.locales.filter((l) => l.enabled && (targets.length === 0 || targets.includes(l.locale)) &&
+                l.published + l.drafts + l.needsReview < status.totalStrings);
+            if (pending.length === 0) {
+                sp.succeed("drafting complete");
+                break;
+            }
+            if (Date.now() > deadline) {
+                sp.fail("timed out waiting for drafts");
+                throw new CliError(`still pending: ${pending.map((l) => l.locale).join(", ")}`);
+            }
+            const done = status.locales.filter((l) => l.enabled).length - pending.length;
+            sp.update(`drafting ${done}/${status.locales.filter((l) => l.enabled).length} languages ready ${dim(pending.map((l) => l.locale).join(" "))}`);
+            await new Promise((r) => setTimeout(r, 3000));
+        }
+    }
+    const status = await admin.status(api, token, projectId);
+    if (targets.length === 0) {
+        targets = status.locales.filter((l) => l.enabled && l.drafts > 0).map((l) => l.locale);
+        if (targets.length === 0) {
+            console.log("nothing to publish — no pending drafts");
+            return;
+        }
+    }
+    const review = status.locales
+        .filter((l) => targets.includes(l.locale) && l.needsReview > 0);
+    if (review.length > 0) {
+        console.log(`  ${S.warn} ${yellow(`${review.map((l) => `${l.locale} (${l.needsReview})`).join(", ")} have needs-review strings — they stay unpublished`)}`);
+    }
+    if (!(await confirm(`Publish ${targets.join(", ")}?`, flags.yes)))
+        throw new CliError("aborted", 2);
+    const sp2 = spin(`publishing ${targets.join(", ")}`);
+    const result = await admin.publish(api, token, projectId, targets);
+    sp2.succeed("published");
+    console.log();
+    console.log(box(result.published.map((p) => `${flag(p.locale)} ${c.accent2(p.locale.padEnd(7))} ${S.arrow} ${c.text(`bundle v${p.bundleVersion}`)}`), "live on the CDN", c.accent));
+    note("devices pick this up on next app foreground");
+    console.log();
+}
+// ---- status ----
+export async function status(flags) {
+    const { config, token, projectId } = await resolveProject();
+    const s = await admin.status(apiOf(config), token, projectId);
+    if (flags.json) {
+        console.log(JSON.stringify(s, null, 2));
+    }
+    else {
+        const enabled = s.locales.filter((l) => l.enabled);
+        const avgCoverage = enabled.length
+            ? Math.round(enabled.reduce((a, l) => a + l.coveragePct, 0) / enabled.length) : 0;
+        const draftCount = enabled.reduce((a, l) => a + l.drafts, 0);
+        const reviewCount = enabled.reduce((a, l) => a + l.needsReview, 0);
+        const latest = enabled.map((l) => l.lastPublish).filter(Boolean)
+            .sort((a, b) => (a.at < b.at ? 1 : -1))[0];
+        const failed = s.deadLetter.reduce((a, d) => a + d.n, 0);
+        header(s.project.name, `${config.projectKey.slice(0, 16)}… ${g.sep} source ${s.project.sourceLocale}`);
+        kv("coverage", `${bar(avgCoverage, 22)} ${pctLabel(avgCoverage)}  ${c.muted(`across ${enabled.length} languages`)}`);
+        kv("strings", `${c.text(String(s.totalStrings))} ${c.muted("source")}  ${draftCount > 0 ? c.danger(`${draftCount} drafts pending`) : c.muted("no drafts pending")}  ${reviewCount > 0 ? c.negative(`${reviewCount} need review`) : c.muted("0 need review")}`);
+        kv("delivery", latest
+            ? `${c.text(`bundle v${latest.bundleVersion}`)} ${c.positive("live")} ${c.muted(`${g.sep} published ${relativeTime(latest.at)}`)}`
+            : c.muted("nothing published yet"));
+        kv("jobs", failed > 0 ? c.negative(`${failed} failed — inspect with status --json`) : c.positive("all healthy"));
+        section("languages");
+        console.log(table(["", "locale", "coverage", "", "drafts", "review", "bundle"], enabled.map((l) => [
+            flag(l.locale),
+            c.accent2(l.locale),
+            bar(l.coveragePct),
+            pctLabel(l.coveragePct),
+            l.drafts > 0 ? c.danger(String(l.drafts)) : c.muted("0"),
+            l.needsReview > 0 ? c.negative(String(l.needsReview)) : c.muted("0"),
+            l.lastPublish ? c.muted(`v${l.lastPublish.bundleVersion}`) : c.muted("—"),
+        ])));
+        console.log();
+    }
+    if (s.deadLetter.length > 0)
+        process.exit(1);
+}
+// ---- doctor ----
+export async function doctor() {
+    header("doctor", "local + remote checks");
+    let failures = 0;
+    const check = async (label, fn) => {
+        const sp = spin(label);
+        try {
+            const detail = await fn();
+            sp.succeed(`${label}${detail ? dim(`  ${detail}`) : ""}`);
+        }
+        catch (err) {
+            failures++;
+            sp.fail(label);
+            console.log(`      ${dim("fix:")} ${err.message}`);
+        }
+    };
+    const found = findConfig();
+    await check("polycast.json present and valid", () => {
+        if (!found)
+            throw new Error("run `polycast init`");
+        return found.config.projectKey.slice(0, 12) + "…";
+    });
+    if (!found) {
+        process.exit(1);
+    }
+    const { config, dir } = found;
+    await check("catalog parses", () => {
+        const { strings } = parseCatalog(path.resolve(dir, config.catalogPath));
+        return `${strings.length} strings`;
+    });
+    await check("build plugin attached", () => {
+        const candidates = [path.join(dir, "Package.swift"),
+            ...readdirSync(dir).filter((f) => f.endsWith(".xcodeproj")).map((f) => path.join(dir, f, "project.pbxproj"))];
+        const hit = candidates.some((f) => existsSync(f) && readFileSync(f, "utf8").includes("PolycastBuildPlugin"));
+        if (!hit)
+            throw new Error("add PolycastBuildPlugin to your target (see `polycast init` output); if using the plugin, strings push automatically on build");
+    });
+    await check(".polycast/ gitignored", () => {
+        try {
+            // Respects parent/global gitignores, unlike a flat file check.
+            execSync("git check-ignore -q .polycast", { cwd: dir, stdio: "ignore" });
+            return;
+        }
+        catch { /* not ignored, or not a git repo — fall back */ }
+        const gi = path.join(dir, ".gitignore");
+        if (!existsSync(gi) || !readFileSync(gi, "utf8").includes(".polycast")) {
+            throw new Error("add `.polycast/` to .gitignore");
+        }
+    });
+    await check("project key authenticates", async () => {
+        await project.pushStrings(apiOf(config), config.projectKey, {
+            schemaVersion: 1, projectKey: config.projectKey,
+            sourceLocale: "en", strings: [],
+        });
+    });
+    await check("admin token valid", async () => {
+        const token = loadToken();
+        if (!token)
+            return "not logged in (fine for CI; needed for langs/publish/status)";
+        await admin.resolveKey(apiOf(config), token, config.projectKey);
+    });
+    await check("edge reachable", async () => {
+        const manifest = await edge.manifest(edgeOf(config), config.projectKey);
+        return `${manifest.locales.length} locale(s) live`;
+    });
+    await check("ETag/304 round-trip", async () => {
+        const manifest = await edge.manifest(edgeOf(config), config.projectKey);
+        const first = manifest.locales[0];
+        if (!first)
+            return "no bundles published yet — skipped";
+        const res = await edge.raw(edgeOf(config), config.projectKey, first.id);
+        const etag = res.headers.get("etag");
+        if (!etag)
+            throw new Error("edge did not return an ETag");
+        const cached = await edge.raw(edgeOf(config), config.projectKey, first.id, { "If-None-Match": etag });
+        if (cached.status !== 304)
+            throw new Error(`expected 304, got ${cached.status}`);
+    });
+    if (failures > 0) {
+        console.log(`\n  ${S.fail} ${red(`${failures} check(s) failed`)}\n`);
+        process.exit(1);
+    }
+    success("all checks passed");
+}
+// ---- shadow ----
+const SHADOW_CONTENT = `// Generated by \`polycast shadow\`: routes every plain \`Text("…")\` in
+// this module through Polycast (OTA-first, bundled fallback) — including
+// custom components that render via unqualified Text. Opt out per call
+// site with SwiftUI.Text(...) or Text(verbatim:). Do not edit.
+import PolycastSDK
+typealias Text = PText
+`;
+/** Plant Polycast+Shadow.swift into each source module so plain Text —
+ * and any design-system component built on it — renders OTA. */
+export async function shadow(args, _flags) {
+    const { dir } = requireConfig();
+    let targets = args.map((a) => path.resolve(dir, a));
+    if (targets.length === 0) {
+        // Default: every directory that looks like a Swift source root.
+        const roots = new Set();
+        const walk = (d, depth) => {
+            if (depth > 5)
+                return;
+            let entries;
+            try {
+                entries = readdirSync(d);
+            }
+            catch {
+                return;
+            }
+            for (const name of entries) {
+                if (name.startsWith(".") || ["node_modules", "Pods", ".build", "build", "DerivedData"].includes(name))
+                    continue;
+                const full = path.join(d, name);
+                try {
+                    if (statSync(full).isDirectory())
+                        walk(full, depth + 1);
+                    else if (name.endsWith(".swift") && !name.startsWith("Polycast+") && name !== "Package.swift")
+                        roots.add(d);
+                }
+                catch { /* skip */ }
+            }
+        };
+        walk(dir, 0);
+        targets = [...roots];
+    }
+    let planted = 0;
+    for (const target of targets) {
+        const file = path.join(target, "Polycast+Shadow.swift");
+        if (existsSync(file))
+            continue;
+        writeFileSync(file, SHADOW_CONTENT);
+        console.log(`  ${S.ok}  ${path.relative(dir, file)}`);
+        planted++;
+    }
+    if (planted === 0) {
+        note("all source modules already shadowed");
+        return;
+    }
+    success(`planted ${planted} shadow file(s) — plain Text now renders OTA in those modules`);
+    note("using XcodeGen? re-run `xcodegen generate` so the new files join the project");
+}
+// ---- gen ----
+function swiftIdent(part) {
+    const cleaned = part.replace(/[^A-Za-z0-9]+(.)?/g, (_, c) => c ? c.toUpperCase() : "");
+    const ident = /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
+    const keywords = new Set(["default", "case", "class", "enum", "struct", "import", "let", "var", "in", "for", "self"]);
+    return keywords.has(ident) ? `\`${ident}\`` : (ident || "_empty");
+}
+export async function gen(flags) {
+    const { config, dir } = requireConfig();
+    const { strings } = parseCatalog(path.resolve(dir, config.catalogPath));
+    const outPath = path.resolve(dir, flags.output ?? "Sources/Generated/PolycastKeys.swift");
+    const root = { children: new Map(), leaves: [] };
+    for (const s of strings) {
+        const parts = s.key.split(".");
+        if (parts.length > 1 && parts.every((p) => /^[A-Za-z0-9_-]+$/.test(p))) {
+            let node = root;
+            for (const part of parts.slice(0, -1)) {
+                if (!node.children.has(part))
+                    node.children.set(part, { children: new Map(), leaves: [] });
+                node = node.children.get(part);
+            }
+            node.leaves.push({ name: swiftIdent(parts[parts.length - 1]), key: s.key });
+        }
+        else {
+            root.leaves.push({ name: swiftIdent(s.key.split(/\s+/).slice(0, 5).join(" ")), key: s.key });
+        }
+    }
+    const emit = (node, name, indent) => {
+        const lines = [`${indent}public enum ${swiftIdent(name)} {`];
+        for (const leaf of node.leaves.sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`${indent}    public static let ${leaf.name} = ${JSON.stringify(leaf.key)}`);
+        }
+        for (const [childName, child] of [...node.children].sort()) {
+            lines.push(emit(child, childName, indent + "    "));
+        }
+        lines.push(`${indent}}`);
+        return lines.join("\n");
+    };
+    const out = `// AUTO-GENERATED by \`polycast gen\` from ${config.catalogPath} — do not edit.
+// Use with Polycast: PText(L.paywall.title) / Polycast.string(L.paywall.title)
+
+${emit(root, "L", "")}
+`;
+    mkdirSync(path.dirname(outPath), { recursive: true });
+    writeFileSync(outPath, out);
+    success(`wrote ${path.relative(dir, outPath)} ${dim(`(${strings.length} keys)`)}`);
+}
+//# sourceMappingURL=commands.js.map