@figtools/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dryor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.es.md

@@ -0,0 +1,89 @@
+*[Read in English](./README.md)*
+
+# @figtools/cli
+
+`@figtools/cli` resuelve una o varias URLs de Figma desde la línea de comandos y escribe el resultado en JSON o en un árbol de Markdown navegable, pensado para que un LLM lo use como fuente de datos sin tener que procesar un único JSON gigante. Usa [`@figtools/core`](../core) por debajo, así que no depende de la REST API oficial de Figma ni de una cuenta con Dev Mode.
+
+## Installation
+
+```bash
+npm install -g @figtools/cli
+npx playwright install chromium
+```
+
+También puedes instalarlo como dependencia local del proyecto y correrlo con `npx figtools`.
+
+## Examples
+
+### Iniciar sesión una sola vez
+
+```bash
+figtools login
+```
+
+Abre una ventana de Chromium en el login de Figma. Completa el login manualmente (soporta el flujo de Google SSO); al terminar, la sesión queda guardada en `~/.figma-scraper/session.json` y los comandos siguientes la reutilizan sin volver a pedir login.
+
+### Resolver una URL a JSON (por defecto, a stdout)
+
+```bash
+figtools "https://www.figma.com/design/ABC123/Mi-Diseno?node-id=1-23"
+```
+
+Si la URL no trae `node-id`, se resuelve la página activa completa del archivo.
+
+### Guardar el resultado en un archivo o carpeta
+
+```bash
+# Un archivo .json puntual
+figtools "https://www.figma.com/design/ABC123/Mi-Diseno?node-id=1-23" --output resultado.json
+
+# Una carpeta: escribe "<carpeta>/<fileKey>-<nodeId>.json"
+figtools "https://www.figma.com/design/ABC123/Mi-Diseno?node-id=1-23" --output ./salida
+```
+
+### Exportar como árbol de Markdown navegable
+
+```bash
+figtools "https://www.figma.com/design/ABC123/Mi-Diseno" --format markdown --output ./docs
+```
+
+Genera `./docs/<fileKey>/index.md` con un link por cada nodo de nivel superior, y una carpeta por cada nodo que tiene hijos (con su propio `index.md`), hasta llegar a los nodos hoja como `<slug>.md`. Este formato está pensado para que un LLM navegue el árbol de a un archivo por vez, en vez de recibir el diseño completo en un solo bloque de JSON.
+
+### Resolver varias URLs en una sola corrida
+
+```bash
+figtools "https://www.figma.com/design/ABC123/A?node-id=1-1" "https://www.figma.com/design/ABC123/A?node-id=1-2" --format markdown --output ./docs
+```
+
+Cada URL se resuelve en paralelo tras autenticar una sola vez. Si alguna falla, el proceso sigue con las demás y termina con código de salida `1`; los errores se listan en stderr al final.
+
+### Silenciar el progreso
+
+```bash
+figtools "https://www.figma.com/design/ABC123/Mi-Diseno" --quiet
+```
+
+Omite el mensaje `Resolving N URL(s)...` en stderr — útil si estás capturando stdout en un script.
+
+## Flags
+
+| Flag | Valores | Default | Descripción |
+| --- | --- | --- | --- |
+| `--format` | `json`, `markdown` | `json` | Formato de salida |
+| `--output` | ruta de archivo o carpeta | stdout (json) / `.` (markdown) | Dónde escribir el resultado |
+| `--quiet` | — | `false` | Omite el mensaje de progreso en stderr |
+
+## Troubleshooting
+
+- **`Error: unsupported extension "<ext>"`**: con `--format markdown`, `--output` siempre se trata como una carpeta. Con `--format json`, solo se acepta una ruta terminada en `.json` o sin extensión (tratada como carpeta); cualquier otra extensión falla explícitamente.
+- **El proceso termina con código `1` pero imprimió resultados**: significa que al menos una de las URLs falló — revisa el bloque `URLs with errors:` al final de stderr para ver el código (`FigmaScraperErrorCode`) y mensaje de cada una. Ver la tabla de errores en el [README de `@figtools/core`](../core/README.es.md#errores-posibles).
+- **`figtools login` no avanza**: la ventana de Chromium espera indefinidamente a que termines el login manual; confirma que llegaste a `https://www.figma.com/files/...` antes de cerrar la ventana.
+
+## Additional resources
+
+- [`@figtools/core`](../core) — la librería subyacente, útil si prefieres integrar la resolución de URLs directamente en tu propio código en vez de invocar un binario.
+- [README del monorepo](../../README.md) — visión general de `figtools`, ADRs y specs de aceptación.
+
+## License
+
+MIT — ver [LICENSE](./LICENSE).

package/README.md

@@ -0,0 +1,89 @@
+*[Leer en español](./README.es.md)*
+
+# @figtools/cli
+
+`@figtools/cli` resolves one or more Figma URLs from the command line and writes the result as JSON or as a navigable Markdown tree, meant to be used by an LLM as a data source without having to parse one giant JSON blob. It uses [`@figtools/core`](../core) under the hood, so it doesn't depend on the official Figma REST API or a Dev Mode account.
+
+## Installation
+
+```bash
+npm install -g @figtools/cli
+npx playwright install chromium
+```
+
+You can also install it as a local project dependency and run it with `npx figtools`.
+
+## Examples
+
+### Log in once
+
+```bash
+figtools login
+```
+
+Opens a Chromium window at the Figma login page. Complete the login manually (the Google SSO flow is supported); once done, the session is saved to `~/.figma-scraper/session.json` and later commands reuse it without asking to log in again.
+
+### Resolve a URL to JSON (stdout by default)
+
+```bash
+figtools "https://www.figma.com/design/ABC123/My-Design?node-id=1-23"
+```
+
+If the URL doesn't include `node-id`, the entire active page of the file is resolved.
+
+### Save the result to a file or folder
+
+```bash
+# A single .json file
+figtools "https://www.figma.com/design/ABC123/My-Design?node-id=1-23" --output result.json
+
+# A folder: writes "<folder>/<fileKey>-<nodeId>.json"
+figtools "https://www.figma.com/design/ABC123/My-Design?node-id=1-23" --output ./output
+```
+
+### Export as a navigable Markdown tree
+
+```bash
+figtools "https://www.figma.com/design/ABC123/My-Design" --format markdown --output ./docs
+```
+
+Generates `./docs/<fileKey>/index.md` with a link for each top-level node, and a folder per node that has children (with its own `index.md`), down to leaf nodes as `<slug>.md`. This format is meant for an LLM to navigate the tree one file at a time, instead of receiving the entire design in a single JSON blob.
+
+### Resolve several URLs in a single run
+
+```bash
+figtools "https://www.figma.com/design/ABC123/A?node-id=1-1" "https://www.figma.com/design/ABC123/A?node-id=1-2" --format markdown --output ./docs
+```
+
+Each URL is resolved in parallel after authenticating once. If any of them fail, the process continues with the rest and exits with code `1`; the errors are listed on stderr at the end.
+
+### Silence progress output
+
+```bash
+figtools "https://www.figma.com/design/ABC123/My-Design" --quiet
+```
+
+Omits the `Resolving N URL(s)...` message on stderr — useful if you're capturing stdout in a script.
+
+## Flags
+
+| Flag | Values | Default | Description |
+| --- | --- | --- | --- |
+| `--format` | `json`, `markdown` | `json` | Output format |
+| `--output` | file or folder path | stdout (json) / `.` (markdown) | Where to write the result |
+| `--quiet` | — | `false` | Omits the progress message on stderr |
+
+## Troubleshooting
+
+- **`Error: unsupported extension "<ext>"`**: with `--format markdown`, `--output` is always treated as a folder. With `--format json`, only a path ending in `.json` or with no extension (treated as a folder) is accepted; any other extension fails explicitly.
+- **The process exits with code `1` but printed results**: at least one of the URLs failed — check the `URLs with errors:` block at the end of stderr for each one's code (`FigmaScraperErrorCode`) and message. See the error table in the [`@figtools/core` README](../core#possible-errors).
+- **`figtools login` doesn't progress**: the Chromium window waits indefinitely for you to finish the manual login; confirm you reached `https://www.figma.com/files/...` before closing the window.
+
+## Additional resources
+
+- [`@figtools/core`](../core) — the underlying library, useful if you'd rather integrate URL resolution directly into your own code instead of invoking a binary.
+- [Monorepo README](../../README.md) — overview of `figtools`, ADRs, and acceptance specs.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/cli.d.ts

@@ -0,0 +1,35 @@
+export type OutputFormat = "json" | "markdown";
+export interface ParsedArgs {
+    urls: string[];
+    format: OutputFormat;
+    outputPath?: string;
+    quiet: boolean;
+    command?: "login";
+}
+type ParseArgsError = {
+    code: "VALIDATION_NO_URLS" | "VALIDATION_UNSUPPORTED_EXTENSION";
+    message: string;
+};
+export type ParseArgsResult = {
+    ok: true;
+    value: ParsedArgs;
+} | {
+    ok: false;
+    error: ParseArgsError;
+};
+export type OutputTarget = {
+    kind: "stdout";
+} | {
+    kind: "file";
+    path: string;
+} | {
+    kind: "directory";
+    path: string;
+} | {
+    kind: "unsupported-extension";
+    extension: string;
+};
+export declare function parseArgs(argv: string[]): ParseArgsResult;
+export declare function decideOutputTarget(outputPath: string | undefined, format: OutputFormat): OutputTarget;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,CAAC;AAE/C,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,oBAAoB,GAAG,kCAAkC,CAAC;IAChE,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,eAAe,GACvB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAC/B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,cAAc,CAAA;CAAE,CAAC;AAEzC,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,uBAAuB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,CA+BzD;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,MAAM,EAAE,YAAY,GACnB,YAAY,CAad"}

package/dist/cli.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import { extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CookieSessionStore, PlaywrightFigmaGateway, PlaywrightLogin, createFigmaScraperCore } from "@figtools/core";
+import { mkdir, writeFile } from "node:fs/promises";
+async function resolveAll(core, urls) {
+    const sessionResult = await core.ensureSession();
+    if (!sessionResult.ok) return urls.map((url)=>({
+            url,
+            result: sessionResult
+        }));
+    const settled = await Promise.allSettled(urls.map((url)=>core.resolveUrl(url)));
+    return urls.map((url, i)=>{
+        const outcome = settled[i];
+        if ("fulfilled" === outcome.status) return {
+            url,
+            result: outcome.value
+        };
+        return {
+            url,
+            result: {
+                ok: false,
+                error: {
+                    code: "AUTHENTICATION_FAILED",
+                    message: "Unexpected error while resolving the URL"
+                }
+            }
+        };
+    });
+}
+async function writeAsJson(fileKey, result, options) {
+    const json = JSON.stringify(result, null, 2);
+    if (!options.outputPath) return void console.log(json);
+    const { outputPath } = options;
+    if (".json" === extname(outputPath)) return void await writeFile(outputPath, json, "utf8");
+    await mkdir(outputPath, {
+        recursive: true
+    });
+    const nodeId = result.id.replace(/:/g, "-");
+    await writeFile(join(outputPath, `${fileKey}-${nodeId}.json`), json, "utf8");
+}
+function slugify(name) {
+    return name.replace(/\s*\([^)]*\)/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function slugifyWithCollisions(names) {
+    const slugs = names.map(slugify);
+    const count = new Map();
+    return slugs.map((slug)=>{
+        const n = (count.get(slug) ?? 0) + 1;
+        count.set(slug, n);
+        return 1 === n ? slug : `${slug}-[${n}]`;
+    });
+}
+function isFigmaPage(result) {
+    return "nodes" in result;
+}
+function leafContent(node) {
+    return `# ${node.name}\n\ntype: ${node.type}\n`;
+}
+function containerContent(name, children, childSlugs) {
+    const links = children.map((child, i)=>{
+        const slug = childSlugs[i];
+        const href = 0 === child.children.length ? `${slug}.md` : `${slug}/index.md`;
+        return `- [${child.name}](${href})`;
+    }).join("\n");
+    return `# ${name}\n\n${links}\n`;
+}
+async function writeChildNode(node, parentDir, slug) {
+    if (0 === node.children.length) return void await writeFile(join(parentDir, `${slug}.md`), leafContent(node), "utf8");
+    const nodeDir = join(parentDir, slug);
+    await mkdir(nodeDir, {
+        recursive: true
+    });
+    const childSlugs = slugifyWithCollisions(node.children.map((c)=>c.name));
+    await writeFile(join(nodeDir, "index.md"), containerContent(node.name, node.children, childSlugs), "utf8");
+    for(let i = 0; i < node.children.length; i++)await writeChildNode(node.children[i], nodeDir, childSlugs[i]);
+}
+async function writeAsMarkdownTree(fileKey, result, options) {
+    const fileKeyDir = join(options.outputDir, fileKey);
+    await mkdir(fileKeyDir, {
+        recursive: true
+    });
+    if (isFigmaPage(result)) {
+        const childSlugs = slugifyWithCollisions(result.nodes.map((n)=>n.name));
+        await writeFile(join(fileKeyDir, "index.md"), containerContent(result.name, result.nodes, childSlugs), "utf8");
+        for(let i = 0; i < result.nodes.length; i++)await writeChildNode(result.nodes[i], fileKeyDir, childSlugs[i]);
+        return;
+    }
+    if (0 === result.children.length) {
+        const [slug] = slugifyWithCollisions([
+            result.name
+        ]);
+        await writeFile(join(fileKeyDir, `${slug}.md`), leafContent(result), "utf8");
+        return;
+    }
+    const childSlugs = slugifyWithCollisions(result.children.map((c)=>c.name));
+    await writeFile(join(fileKeyDir, "index.md"), containerContent(result.name, result.children, childSlugs), "utf8");
+    for(let i = 0; i < result.children.length; i++)await writeChildNode(result.children[i], fileKeyDir, childSlugs[i]);
+}
+function parseArgs(argv) {
+    if ("login" === argv[0]) return {
+        ok: true,
+        value: {
+            command: "login",
+            urls: [],
+            format: "json",
+            quiet: false
+        }
+    };
+    let format = "json";
+    let outputPath;
+    let quiet = false;
+    const urls = [];
+    for(let i = 0; i < argv.length; i++){
+        const arg = argv[i];
+        if ("--format" === arg) format = argv[++i];
+        else if ("--output" === arg) outputPath = argv[++i];
+        else if ("--quiet" === arg) quiet = true;
+        else if (!arg.startsWith("--")) urls.push(arg);
+    }
+    if (0 === urls.length) return {
+        ok: false,
+        error: {
+            code: "VALIDATION_NO_URLS",
+            message: "At least one Figma URL is required"
+        }
+    };
+    return {
+        ok: true,
+        value: {
+            urls,
+            format,
+            outputPath,
+            quiet
+        }
+    };
+}
+function decideOutputTarget(outputPath, format) {
+    if (!outputPath) return "markdown" === format ? {
+        kind: "directory",
+        path: "."
+    } : {
+        kind: "stdout"
+    };
+    if ("markdown" === format) return {
+        kind: "directory",
+        path: outputPath
+    };
+    const ext = extname(outputPath);
+    if (!ext) return {
+        kind: "directory",
+        path: outputPath
+    };
+    if (".json" === ext) return {
+        kind: "file",
+        path: outputPath
+    };
+    return {
+        kind: "unsupported-extension",
+        extension: ext
+    };
+}
+function extractFileKey(url) {
+    const match = url.match(/\/(?:file|design|proto|board)\/([^/?]+)/);
+    return match ? match[1] : url;
+}
+async function main(argv) {
+    const parsed = parseArgs(argv);
+    if (!parsed.ok) {
+        process.stderr.write(`Error: ${parsed.error.message}\n`);
+        process.exit(1);
+    }
+    const { command, urls, format, outputPath, quiet } = parsed.value;
+    const core = createFigmaScraperCore({
+        sessionStore: new CookieSessionStore(),
+        interactiveLogin: new PlaywrightLogin(),
+        gateway: new PlaywrightFigmaGateway()
+    });
+    if ("login" === command) {
+        const result = await core.reauthenticate();
+        if (!result.ok) {
+            process.stderr.write(`Authentication error: ${result.error.message}\n`);
+            process.exit(1);
+        }
+        process.stderr.write("Logged in successfully.\n");
+        process.exit(0);
+    }
+    const outputTarget = decideOutputTarget(outputPath, format);
+    if ("unsupported-extension" === outputTarget.kind) {
+        process.stderr.write(`Error: unsupported extension "${outputTarget.extension}"\n`);
+        process.exit(1);
+    }
+    if (!quiet) process.stderr.write(`Resolving ${urls.length} URL(s)...\n`);
+    const resolutions = await resolveAll(core, urls);
+    let hadFailure = false;
+    for (const { url, result } of resolutions){
+        if (!result.ok) {
+            hadFailure = true;
+            continue;
+        }
+        const fileKey = extractFileKey(url);
+        if ("markdown" === format) {
+            const dir = "directory" === outputTarget.kind ? outputTarget.path : ".";
+            await writeAsMarkdownTree(fileKey, result.value, {
+                outputDir: dir
+            });
+        } else {
+            const writePath = "file" === outputTarget.kind ? outputTarget.path : "directory" === outputTarget.kind ? outputTarget.path : void 0;
+            await writeAsJson(fileKey, result.value, {
+                outputPath: writePath
+            });
+        }
+    }
+    const failures = resolutions.filter((r)=>!r.result.ok);
+    if (failures.length > 0) {
+        process.stderr.write("\nURLs with errors:\n");
+        for (const { url, result } of failures)if (!result.ok) process.stderr.write(`  ${url}: ${result.error.code} — ${result.error.message}\n`);
+    }
+    process.exit(hadFailure ? 1 : 0);
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(2));
+export { decideOutputTarget, parseArgs };

package/dist/output/json-writer.d.ts

@@ -0,0 +1,6 @@
+import type { FigmaScrapeResult } from "@figtools/core";
+export interface JsonWriterOptions {
+    outputPath?: string;
+}
+export declare function writeAsJson(fileKey: string, result: FigmaScrapeResult, options: JsonWriterOptions): Promise<void>;
+//# sourceMappingURL=json-writer.d.ts.map

package/dist/output/json-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-writer.d.ts","sourceRoot":"","sources":["../../src/output/json-writer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/output/markdown-writer.d.ts

@@ -0,0 +1,6 @@
+import type { FigmaScrapeResult } from "@figtools/core";
+export interface MarkdownWriterOptions {
+    outputDir: string;
+}
+export declare function writeAsMarkdownTree(fileKey: string, result: FigmaScrapeResult, options: MarkdownWriterOptions): Promise<void>;
+//# sourceMappingURL=markdown-writer.d.ts.map

package/dist/output/markdown-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-writer.d.ts","sourceRoot":"","sources":["../../src/output/markdown-writer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAG9E,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;CACnB;AAoCD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/output/slugify.d.ts

@@ -0,0 +1,2 @@
+export declare function slugifyWithCollisions(names: string[]): string[];
+//# sourceMappingURL=slugify.d.ts.map

package/dist/output/slugify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugify.d.ts","sourceRoot":"","sources":["../../src/output/slugify.ts"],"names":[],"mappings":"AAQA,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAQ/D"}

package/dist/resolve-all.d.ts

@@ -0,0 +1,7 @@
+import type { FigmaScraperCore, FigmaScrapeResult, FigmaScraperError, Result } from "@figtools/core";
+export interface UrlResolution {
+    url: string;
+    result: Result<FigmaScrapeResult, FigmaScraperError>;
+}
+export declare function resolveAll(core: FigmaScraperCore, urls: string[]): Promise<UrlResolution[]>;
+//# sourceMappingURL=resolve-all.d.ts.map

package/dist/resolve-all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-all.d.ts","sourceRoot":"","sources":["../src/resolve-all.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAErG,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC;CACtD;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,aAAa,EAAE,CAAC,CAsB1B"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@figtools/cli",
+  "version": "0.1.0",
+  "description": "Resolves one or more Figma URLs from the command line and writes the result as JSON or as a navigable markdown tree meant to be used as a data source by an LLM.",
+  "keywords": [
+    "figma",
+    "figma-api",
+    "cli",
+    "scraper",
+    "markdown",
+    "llm"
+  ],
+  "homepage": "https://github.com/dryor/figtools#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dryor/figtools.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/dryor/figtools/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "figtools": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "playwright": "^1.61.1",
+    "@figtools/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.23.2",
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "test": "vitest run --project unit",
+    "test:watch": "vitest --project unit",
+    "typecheck": "tsc --noEmit"
+  }
+}