styleflow 0.1.0

package/README.md

@@ -0,0 +1,30 @@
+# styleflow
+
+Design-to-dev CLI for StyleFlow projects.
+
+## Install
+
+```bash
+npm install --save-dev styleflow
+```
+
+## Quick start
+
+```bash
+npx styleflow init
+npx styleflow pull
+npx styleflow build
+```
+
+## Commands
+
+- `styleflow init`: create `styleflow.config.ts` and ensure required `.env` keys.
+- `styleflow pull [all|tokens|stylesheet|figma-styles]`: pull project artifacts.
+- `styleflow build`: build output files from pulled artifacts.
+
+## Environment
+
+- `STYLEFLOW_TOKEN`
+- `STYLEFLOW_PROJECT_ID`
+- `STYLEFLOW_API_URL` (default: `https://api.styleflow.app`)
+- `STYLEFLOW_PROJECT_VERSION_ID` (optional)

package/dist/build.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedStyleflowRuntimeConfig } from "./types.js";
+type BuildOutputFile = {
+    type: string;
+    format: string;
+    path: string;
+};
+export interface BuildResult {
+    rawDirectory: string;
+    outputFiles: BuildOutputFile[];
+    warnings: string[];
+}
+export declare function buildStyleflowOutputs(runtime: ResolvedStyleflowRuntimeConfig): Promise<BuildResult>;
+export {};
+//# sourceMappingURL=build.d.ts.map

package/dist/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,8BAA8B,EAG/B,MAAM,YAAY,CAAC;AAEpB,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAyED,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,WAAW,CAAC,CA4ItB"}

package/dist/build.js

@@ -0,0 +1,185 @@
+import path from "node:path";
+import { ensureDirectory, readJsonFile, writeJsonFile, writeTextFile } from "./fs.js";
+import { exportCSS, exportSCSS, exportStyleDictionary, exportTailwindPreset, } from "./generators/export.js";
+function normalizeTokenFormat(format) {
+    const normalized = String(format || "css")
+        .trim()
+        .toLowerCase();
+    if (normalized === "css")
+        return "css";
+    if (normalized === "scss")
+        return "scss";
+    if (normalized === "json")
+        return "json";
+    if (normalized === "style-dictionary" || normalized === "style_dictionary") {
+        return "style-dictionary";
+    }
+    if (normalized === "tailwind")
+        return "tailwind";
+    throw new Error(`Unsupported token output format "${String(format)}". Use css|scss|json|style-dictionary|tailwind.`);
+}
+function getTokenOutputPath(runtime) {
+    const configured = runtime.config.output?.tokens?.path;
+    if (typeof configured === "string" && configured.trim().length > 0) {
+        return path.resolve(runtime.cwd, configured.trim());
+    }
+    return path.resolve(runtime.cwd, ".styleflow/build/tokens.css");
+}
+function getTokenOutputFormat(runtime) {
+    return normalizeTokenFormat(runtime.config.output?.tokens?.format || "css");
+}
+function getRawFilePath(runtime, fileName) {
+    return path.join(path.resolve(runtime.cwd, runtime.rawDirectory), fileName);
+}
+function hasObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function collectStylesheetClassMap(stylesheet, mapping, componentsConfig) {
+    if (!hasObject(stylesheet)) {
+        return {
+            framework: componentsConfig.framework || "react",
+            styling: componentsConfig.styling || "tailwind",
+            classes: {},
+        };
+    }
+    const classes = hasObject(stylesheet.classes)
+        ? stylesheet.classes
+        : {};
+    const classMap = {};
+    for (const className of Object.keys(classes).sort()) {
+        classMap[className] = {
+            mappedTo: mapping?.[className] || null,
+            source: "stylesheet",
+        };
+    }
+    return {
+        framework: componentsConfig.framework || "react",
+        styling: componentsConfig.styling || "tailwind",
+        classes: classMap,
+    };
+}
+export async function buildStyleflowOutputs(runtime) {
+    const rawDirectory = path.resolve(runtime.cwd, runtime.rawDirectory);
+    const outputFiles = [];
+    const warnings = [];
+    const tokenOutputPath = getTokenOutputPath(runtime);
+    const tokenOutputFormat = getTokenOutputFormat(runtime);
+    const tokensRawPath = getRawFilePath(runtime, "tokens.structured.json");
+    let tokensData;
+    try {
+        const rawTokens = await readJsonFile(tokensRawPath);
+        if (!hasObject(rawTokens)) {
+            throw new Error("Invalid tokens payload: expected object.");
+        }
+        const files = hasObject(rawTokens.files)
+            ? rawTokens.files
+            : {};
+        const collections = hasObject(rawTokens.collections)
+            ? rawTokens.collections
+            : {};
+        tokensData = { files, collections };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to read tokens raw data at "${tokensRawPath}". Run "styleflow pull" first. (${message})`);
+    }
+    const tokenOutputDir = path.dirname(tokenOutputPath);
+    await ensureDirectory(tokenOutputDir);
+    switch (tokenOutputFormat) {
+        case "css": {
+            const css = exportCSS(tokensData);
+            await writeTextFile(tokenOutputPath, css);
+            outputFiles.push({ type: "tokens", format: "css", path: tokenOutputPath });
+            break;
+        }
+        case "scss": {
+            const scss = exportSCSS(tokensData);
+            await writeTextFile(tokenOutputPath, scss);
+            outputFiles.push({ type: "tokens", format: "scss", path: tokenOutputPath });
+            break;
+        }
+        case "json": {
+            await writeJsonFile(tokenOutputPath, tokensData);
+            outputFiles.push({ type: "tokens", format: "json", path: tokenOutputPath });
+            break;
+        }
+        case "style-dictionary": {
+            const sd = exportStyleDictionary(tokensData);
+            await writeJsonFile(tokenOutputPath, sd);
+            outputFiles.push({
+                type: "tokens",
+                format: "style-dictionary",
+                path: tokenOutputPath,
+            });
+            break;
+        }
+        case "tailwind": {
+            const preset = exportTailwindPreset(tokensData);
+            await writeTextFile(tokenOutputPath, preset);
+            outputFiles.push({
+                type: "tokens",
+                format: "tailwind",
+                path: tokenOutputPath,
+            });
+            break;
+        }
+    }
+    const stylesheetOutput = runtime.config.output?.stylesheet;
+    if (stylesheetOutput?.path) {
+        const stylesheetRawPath = getRawFilePath(runtime, "stylesheet.json");
+        try {
+            const stylesheetData = await readJsonFile(stylesheetRawPath);
+            const resolvedOutputPath = path.resolve(runtime.cwd, stylesheetOutput.path);
+            await writeJsonFile(resolvedOutputPath, stylesheetData);
+            outputFiles.push({
+                type: "stylesheet",
+                format: "json",
+                path: resolvedOutputPath,
+            });
+        }
+        catch {
+            warnings.push(`Stylesheet output skipped: raw file not found at "${stylesheetRawPath}".`);
+        }
+    }
+    const figmaStylesOutput = runtime.config.output?.figmaStyles;
+    if (figmaStylesOutput?.path) {
+        const figmaStylesRawPath = getRawFilePath(runtime, "figma-styles.json");
+        try {
+            const figmaStylesData = await readJsonFile(figmaStylesRawPath);
+            const resolvedOutputPath = path.resolve(runtime.cwd, figmaStylesOutput.path);
+            await writeJsonFile(resolvedOutputPath, figmaStylesData);
+            outputFiles.push({
+                type: "figma-styles",
+                format: "json",
+                path: resolvedOutputPath,
+            });
+        }
+        catch {
+            warnings.push(`Figma styles output skipped: raw file not found at "${figmaStylesRawPath}".`);
+        }
+    }
+    const componentsOutput = runtime.config.output?.components;
+    if (componentsOutput?.path) {
+        const stylesheetRawPath = getRawFilePath(runtime, "stylesheet.json");
+        try {
+            const stylesheetData = await readJsonFile(stylesheetRawPath);
+            const componentDir = path.resolve(runtime.cwd, componentsOutput.path);
+            const mapPath = path.join(componentDir, "styleflow-components.map.json");
+            const mapData = collectStylesheetClassMap(stylesheetData, runtime.config.mapping?.classes, componentsOutput);
+            await writeJsonFile(mapPath, mapData);
+            outputFiles.push({
+                type: "components",
+                format: "mapping-json",
+                path: mapPath,
+            });
+        }
+        catch {
+            warnings.push(`Components mapping skipped: stylesheet raw file not found at "${stylesheetRawPath}".`);
+        }
+    }
+    return {
+        rawDirectory,
+        outputFiles,
+        warnings,
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+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":""}

package/dist/cli.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Command } from "commander";
+import { ensureEnvKeys, getDefaultConfigTemplate, loadStyleflowConfig, resolveRuntimeConfig, } from "./config.js";
+import { buildStyleflowOutputs } from "./build.js";
+import { normalizePullResources, pullStyleflowData } from "./pull.js";
+const CLI_VERSION = "0.1.0";
+function formatError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function logInfo(message) {
+    process.stdout.write(`[styleflow] ${message}\n`);
+}
+function logWarn(message) {
+    process.stderr.write(`[styleflow] ${message}\n`);
+}
+async function buildRuntime(options) {
+    const cwd = process.cwd();
+    const loaded = await loadStyleflowConfig(cwd, options.config);
+    return resolveRuntimeConfig(loaded, {
+        projectId: options.projectId,
+        projectVersionId: options.projectVersionId ?? null,
+        apiUrl: options.apiUrl,
+        token: options.token,
+        rawDirectory: options.rawDirectory,
+    });
+}
+function resolveInitConfigPath(configArg) {
+    const cwd = process.cwd();
+    if (configArg && configArg.trim()) {
+        return path.resolve(cwd, configArg.trim());
+    }
+    return path.resolve(cwd, "styleflow.config.ts");
+}
+async function runPull(resourceArg, options) {
+    const runtime = await buildRuntime(options);
+    const resources = normalizePullResources(resourceArg || "all");
+    const result = await pullStyleflowData(runtime, resources);
+    logInfo(`pull completed for project "${runtime.projectId}"`);
+    logInfo(`raw directory: ${result.rawDirectory}`);
+    for (const resource of result.pulledResources) {
+        logInfo(`- pulled ${resource}: ${result.files[resource].path}`);
+    }
+    for (const resource of result.skippedResources) {
+        logWarn(`- skipped ${resource}`);
+    }
+    for (const warning of result.warnings) {
+        logWarn(`warning: ${warning}`);
+    }
+    logInfo(`manifest: ${result.manifestPath}`);
+}
+async function runBuild(options) {
+    const runtime = await buildRuntime(options);
+    if (options.pull) {
+        const resources = normalizePullResources(options.pullResource || "all");
+        const pullResult = await pullStyleflowData(runtime, resources);
+        logInfo(`pre-build pull completed (${pullResult.pulledResources.length} resources)`);
+    }
+    const result = await buildStyleflowOutputs(runtime);
+    logInfo(`build completed from raw directory: ${result.rawDirectory}`);
+    for (const file of result.outputFiles) {
+        logInfo(`- ${file.type} (${file.format}): ${file.path}`);
+    }
+    for (const warning of result.warnings) {
+        logWarn(`warning: ${warning}`);
+    }
+}
+async function runInit(options) {
+    const configPath = resolveInitConfigPath(options.config);
+    if (existsSync(configPath) && !options.force) {
+        throw new Error(`Config already exists at "${configPath}". Use --force to overwrite.`);
+    }
+    const template = getDefaultConfigTemplate();
+    await fs.writeFile(configPath, template, "utf8");
+    const envResult = await ensureEnvKeys(process.cwd());
+    logInfo(`config created: ${configPath}`);
+    if (envResult.addedKeys.length > 0) {
+        logInfo(`env updated (${envResult.envPath}): ${envResult.addedKeys.join(", ")}`);
+    }
+    else {
+        logInfo(`env already configured: ${envResult.envPath}`);
+    }
+    if (options.projectId && options.projectId.trim()) {
+        logInfo(`set STYLEFLOW_PROJECT_ID="${options.projectId.trim()}" in ${envResult.envPath}`);
+    }
+    if (options.apiUrl && options.apiUrl.trim()) {
+        logInfo(`set STYLEFLOW_API_URL="${options.apiUrl.trim()}" in ${envResult.envPath}`);
+    }
+}
+async function main() {
+    const program = new Command();
+    program
+        .name("styleflow")
+        .version(CLI_VERSION)
+        .description("StyleFlow design-to-dev CLI");
+    program
+        .command("init")
+        .description("Create styleflow.config.ts and ensure required .env keys")
+        .option("-c, --config <path>", "Config output path")
+        .option("-f, --force", "Overwrite existing config", false)
+        .option("--project-id <id>", "Initial project id hint")
+        .option("--api-url <url>", "Initial API URL hint")
+        .action(async (options) => {
+        await runInit(options);
+    });
+    program
+        .command("pull [resource]")
+        .description("Pull data from StyleFlow API into raw directory")
+        .option("-c, --config <path>", "Path to styleflow config file")
+        .option("--project-id <id>", "Override project id")
+        .option("--project-version-id <id>", "Override project version id")
+        .option("--api-url <url>", "Override API URL")
+        .option("--token <token>", "Override API token")
+        .option("--raw-directory <path>", "Override raw directory")
+        .action(async (resource, options) => {
+        await runPull(resource, options);
+    });
+    program
+        .command("build")
+        .description("Build output files from pulled raw data")
+        .option("-c, --config <path>", "Path to styleflow config file")
+        .option("--project-id <id>", "Override project id")
+        .option("--project-version-id <id>", "Override project version id")
+        .option("--api-url <url>", "Override API URL")
+        .option("--token <token>", "Override API token")
+        .option("--raw-directory <path>", "Override raw directory")
+        .option("--pull", "Run pull before build", false)
+        .option("--pull-resource <resource>", "Resource to pull before build (all|tokens|stylesheet|figma-styles)")
+        .action(async (options) => {
+        await runBuild(options);
+    });
+    program
+        .command("get:all")
+        .description("Alias for: styleflow pull all")
+        .option("-c, --config <path>", "Path to styleflow config file")
+        .option("--project-id <id>", "Override project id")
+        .option("--project-version-id <id>", "Override project version id")
+        .option("--api-url <url>", "Override API URL")
+        .option("--token <token>", "Override API token")
+        .option("--raw-directory <path>", "Override raw directory")
+        .action(async (options) => {
+        await runPull("all", options);
+    });
+    program
+        .command("get:tokens")
+        .description("Alias for: styleflow pull tokens")
+        .option("-c, --config <path>", "Path to styleflow config file")
+        .option("--project-id <id>", "Override project id")
+        .option("--project-version-id <id>", "Override project version id")
+        .option("--api-url <url>", "Override API URL")
+        .option("--token <token>", "Override API token")
+        .option("--raw-directory <path>", "Override raw directory")
+        .action(async (options) => {
+        await runPull("tokens", options);
+    });
+    program
+        .command("get:stylesheet")
+        .description("Alias for: styleflow pull stylesheet")
+        .option("-c, --config <path>", "Path to styleflow config file")
+        .option("--project-id <id>", "Override project id")
+        .option("--project-version-id <id>", "Override project version id")
+        .option("--api-url <url>", "Override API URL")
+        .option("--token <token>", "Override API token")
+        .option("--raw-directory <path>", "Override raw directory")
+        .action(async (options) => {
+        await runPull("stylesheet", options);
+    });
+    program
+        .command("get:figma-styles")
+        .description("Alias for: styleflow pull figma-styles")
+        .option("-c, --config <path>", "Path to styleflow config file")
+        .option("--project-id <id>", "Override project id")
+        .option("--project-version-id <id>", "Override project version id")
+        .option("--api-url <url>", "Override API URL")
+        .option("--token <token>", "Override API token")
+        .option("--raw-directory <path>", "Override raw directory")
+        .action(async (options) => {
+        await runPull("figma-styles", options);
+    });
+    await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+    logWarn(`error: ${formatError(error)}`);
+    process.exit(1);
+});

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+import type { LoadedStyleflowConfig, ResolvedStyleflowRuntimeConfig } from "./types.js";
+export declare function loadStyleflowConfig(cwd: string, explicitPath?: string): Promise<LoadedStyleflowConfig>;
+export declare function resolveRuntimeConfig(loaded: LoadedStyleflowConfig, overrides?: {
+    projectId?: string;
+    projectVersionId?: string | null;
+    apiUrl?: string;
+    token?: string;
+    rawDirectory?: string;
+}): ResolvedStyleflowRuntimeConfig;
+export declare function getDefaultConfigTemplate(): string;
+export declare function ensureEnvKeys(cwd: string): Promise<{
+    envPath: string;
+    addedKeys: string[];
+}>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,qBAAqB,EACrB,8BAA8B,EAE/B,MAAM,YAAY,CAAC;AAsEpB,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,EACX,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,qBAAqB,CAAC,CAShC;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,qBAAqB,EAC7B,SAAS,GAAE;IACT,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CAClB,GACL,8BAA8B,CA0DhC;AAED,wBAAgB,wBAAwB,IAAI,MAAM,CA+BjD;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC,CA6BD"}

package/dist/config.js

@@ -0,0 +1,170 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { createJiti } from "jiti";
+const DEFAULT_CONFIG_FILENAMES = [
+    "styleflow.config.ts",
+    "styleflow.config.mts",
+    "styleflow.config.cts",
+    "styleflow.config.mjs",
+    "styleflow.config.cjs",
+    "styleflow.config.js",
+    "styleflow.config.json",
+];
+const DEFAULT_API_URL = "https://api.styleflow.app";
+const DEFAULT_RAW_DIRECTORY = ".styleflow/raw";
+function sanitizeApiUrl(value) {
+    const raw = String(value || "").trim();
+    const candidate = raw || DEFAULT_API_URL;
+    return candidate.replace(/\/+$/, "");
+}
+function resolveConfigPath(cwd, explicitPath) {
+    if (explicitPath && explicitPath.trim()) {
+        const absolute = path.resolve(cwd, explicitPath.trim());
+        return existsSync(absolute) ? absolute : null;
+    }
+    for (const filename of DEFAULT_CONFIG_FILENAMES) {
+        const absolute = path.resolve(cwd, filename);
+        if (existsSync(absolute)) {
+            return absolute;
+        }
+    }
+    return null;
+}
+async function readConfigModule(configPath) {
+    if (configPath.endsWith(".json")) {
+        const raw = await fs.readFile(configPath, "utf8");
+        return JSON.parse(raw);
+    }
+    if (configPath.endsWith(".cjs")) {
+        const req = createRequire(import.meta.url);
+        return req(configPath);
+    }
+    const jiti = createJiti(import.meta.url, {
+        interopDefault: true,
+        moduleCache: false,
+    });
+    return jiti.import(configPath);
+}
+function normalizeLoadedConfig(input) {
+    if (!input)
+        return {};
+    if (typeof input !== "object") {
+        throw new Error("Invalid StyleFlow config: expected object export.");
+    }
+    const record = input;
+    const maybeDefault = record.default;
+    if (maybeDefault && typeof maybeDefault === "object") {
+        return maybeDefault;
+    }
+    return record;
+}
+export async function loadStyleflowConfig(cwd, explicitPath) {
+    const configPath = resolveConfigPath(cwd, explicitPath);
+    if (!configPath) {
+        return { config: {}, configPath: null, cwd };
+    }
+    const loaded = await readConfigModule(configPath);
+    const config = normalizeLoadedConfig(loaded);
+    return { config, configPath, cwd };
+}
+export function resolveRuntimeConfig(loaded, overrides = {}) {
+    const env = process.env;
+    const config = loaded.config || {};
+    const projectId = (overrides.projectId && overrides.projectId.trim()) ||
+        (typeof config.projectId === "string" ? config.projectId.trim() : "") ||
+        (env.STYLEFLOW_PROJECT_ID || "").trim();
+    if (!projectId) {
+        throw new Error("Missing project id. Set STYLEFLOW_PROJECT_ID or define projectId in styleflow.config.");
+    }
+    const token = (overrides.token && overrides.token.trim()) ||
+        (typeof config.auth?.token === "string" ? config.auth.token.trim() : "") ||
+        (env.STYLEFLOW_TOKEN || "").trim();
+    if (!token) {
+        throw new Error("Missing token. Set STYLEFLOW_TOKEN or define auth.token in styleflow.config.");
+    }
+    const apiUrl = sanitizeApiUrl(overrides.apiUrl ||
+        config.apiUrl ||
+        env.STYLEFLOW_API_URL ||
+        DEFAULT_API_URL);
+    const projectVersionIdRaw = overrides.projectVersionId ??
+        config.projectVersionId ??
+        env.STYLEFLOW_PROJECT_VERSION_ID ??
+        null;
+    const projectVersionId = typeof projectVersionIdRaw === "string" && projectVersionIdRaw.trim().length > 0
+        ? projectVersionIdRaw.trim()
+        : null;
+    const rawDirectory = (overrides.rawDirectory && overrides.rawDirectory.trim()) ||
+        (typeof config.rawDirectory === "string" ? config.rawDirectory.trim() : "") ||
+        DEFAULT_RAW_DIRECTORY;
+    return {
+        cwd: loaded.cwd,
+        projectId,
+        projectVersionId,
+        apiUrl,
+        token,
+        rawDirectory,
+        config,
+        configPath: loaded.configPath,
+    };
+}
+export function getDefaultConfigTemplate() {
+    return `export default {
+  projectId: process.env.STYLEFLOW_PROJECT_ID,
+  apiUrl: process.env.STYLEFLOW_API_URL ?? "https://api.styleflow.app",
+  rawDirectory: ".styleflow/raw",
+  output: {
+    tokens: {
+      format: "css",
+      path: "src/styles/styleflow-tokens.css"
+    },
+    stylesheet: {
+      format: "json",
+      path: ".styleflow/build/stylesheet.json"
+    },
+    figmaStyles: {
+      format: "json",
+      path: ".styleflow/build/figma-styles.json"
+    },
+    components: {
+      framework: "react",
+      styling: "tailwind",
+      path: ".styleflow/build/components"
+    }
+  },
+  mapping: {
+    classes: {
+      // "btn-primary": "btn btn-primary"
+    }
+  }
+};
+`;
+}
+export async function ensureEnvKeys(cwd) {
+    const envPath = path.resolve(cwd, ".env");
+    const wanted = [
+        ["STYLEFLOW_API_URL", DEFAULT_API_URL],
+        ["STYLEFLOW_PROJECT_ID", ""],
+        ["STYLEFLOW_TOKEN", ""],
+    ];
+    let existing = "";
+    try {
+        existing = await fs.readFile(envPath, "utf8");
+    }
+    catch {
+        existing = "";
+    }
+    const addedKeys = [];
+    const lines = existing.length > 0 ? existing.replace(/\s+$/, "").split("\n") : [];
+    for (const [key, value] of wanted) {
+        const hasKey = lines.some((line) => line.startsWith(`${key}=`));
+        if (!hasKey) {
+            lines.push(`${key}=${value}`);
+            addedKeys.push(key);
+        }
+    }
+    const nextContent = `${lines.join("\n")}\n`;
+    await fs.writeFile(envPath, nextContent, "utf8");
+    return { envPath, addedKeys };
+}

package/dist/fs.d.ts

@@ -0,0 +1,5 @@
+export declare function ensureDirectory(dirPath: string): Promise<void>;
+export declare function writeJsonFile(filePath: string, data: unknown): Promise<void>;
+export declare function readJsonFile<T>(filePath: string): Promise<T>;
+export declare function writeTextFile(filePath: string, content: string): Promise<void>;
+//# sourceMappingURL=fs.d.ts.map

package/dist/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAGA,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpE;AAED,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAGlF;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlE;AAED,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGpF"}

package/dist/fs.js

@@ -0,0 +1,17 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function ensureDirectory(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+export async function writeJsonFile(filePath, data) {
+    await ensureDirectory(path.dirname(filePath));
+    await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+export async function readJsonFile(filePath) {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+}
+export async function writeTextFile(filePath, content) {
+    await ensureDirectory(path.dirname(filePath));
+    await fs.writeFile(filePath, content, "utf8");
+}

package/dist/generators/export.d.ts

@@ -0,0 +1,6 @@
+import type { StructuredTokens } from "../types.js";
+export declare function exportCSS(tokens: StructuredTokens): string;
+export declare function exportSCSS(tokens: StructuredTokens): string;
+export declare function exportStyleDictionary(tokens: StructuredTokens): Record<string, unknown>;
+export declare function exportTailwindPreset(tokens: StructuredTokens): string;
+//# sourceMappingURL=export.d.ts.map

package/dist/generators/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/generators/export.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,aAAa,CAAC;AAgHhE,wBAAgB,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CA4D1D;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CA6C3D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwCvF;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAmCrE"}

package/dist/generators/export.js

@@ -0,0 +1,246 @@
+function tokenNameToCSS(filePath, tokenName) {
+    const parts = filePath.split("/");
+    const fullParts = [...parts, tokenName];
+    return fullParts
+        .map((p) => p.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase())
+        .join("-")
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function tokenNameToSD(filePath, tokenName) {
+    const parts = filePath.split("/");
+    return [...parts, tokenName].map((p) => p
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, ""));
+}
+function resolveValue(value, files, mode, defaultModes, visited = new Set()) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "number")
+        return String(value);
+    if (typeof value === "boolean")
+        return String(value);
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "object") {
+        const obj = value;
+        if ("cssValue" in obj && typeof obj.cssValue === "string") {
+            return obj.cssValue;
+        }
+        if (obj.ref && typeof obj.ref === "string") {
+            const refName = String(obj.ref);
+            if (visited.has(refName))
+                return `/* circular: ${refName} */`;
+            visited.add(refName);
+            const resolved = findTokenValue(refName, files, mode, defaultModes, visited);
+            return resolved ?? `/* unresolved: ${refName} */`;
+        }
+        if (obj.expr && typeof obj.expr === "string") {
+            return String(obj.expr);
+        }
+    }
+    return String(value);
+}
+function findTokenValue(refPath, files, mode, defaultModes, visited = new Set()) {
+    for (const [filePath, tokens] of Object.entries(files)) {
+        for (const [tokenName, tokenData] of Object.entries(tokens)) {
+            const entry = tokenData;
+            const fullName = `${filePath.split("/").slice(1).join("/")}/${tokenName}`.replace(/^\//, "");
+            const withCollection = `${filePath.split("/")[0]}/${fullName}`;
+            if (refPath === fullName || refPath === tokenName || refPath === withCollection) {
+                const collectionName = filePath.split("/")[0];
+                const defMode = defaultModes[collectionName] || mode;
+                const raw = entry.values[mode] ?? entry.values[defMode] ?? Object.values(entry.values)[0];
+                return resolveValue(raw, files, mode, defaultModes, visited);
+            }
+        }
+    }
+    return null;
+}
+function buildDefaultModes(tokens) {
+    const defaultModes = {};
+    for (const [name, meta] of Object.entries(tokens.collections)) {
+        defaultModes[name] = meta.defaultMode;
+    }
+    const allModes = new Set();
+    for (const meta of Object.values(tokens.collections)) {
+        for (const mode of meta.modes) {
+            allModes.add(mode);
+        }
+    }
+    const sortedModes = Array.from(allModes);
+    const primaryDefault = Object.values(tokens.collections)[0]?.defaultMode || sortedModes[0] || "default";
+    return { defaultModes, sortedModes, primaryDefault };
+}
+export function exportCSS(tokens) {
+    const { files } = tokens;
+    const { defaultModes, sortedModes, primaryDefault } = buildDefaultModes(tokens);
+    const output = [];
+    output.push("/* Generated by StyleFlow */");
+    output.push("/* https://styleflow.app */");
+    output.push("");
+    output.push(":root {");
+    for (const [filePath, fileTokens] of Object.entries(files)) {
+        const collectionName = filePath.split("/")[0];
+        for (const [tokenName, tokenData] of Object.entries(fileTokens)) {
+            const entry = tokenData;
+            const cssName = tokenNameToCSS(filePath, tokenName);
+            const defMode = defaultModes[collectionName] || primaryDefault;
+            const raw = entry.values[defMode] ?? Object.values(entry.values)[0];
+            const value = resolveValue(raw, files, defMode, defaultModes);
+            if (value) {
+                output.push(`  --${cssName}: ${value};`);
+            }
+        }
+    }
+    output.push("}");
+    for (const mode of sortedModes) {
+        if (mode === primaryDefault)
+            continue;
+        const overrides = [];
+        for (const [filePath, fileTokens] of Object.entries(files)) {
+            const collectionName = filePath.split("/")[0];
+            const defMode = defaultModes[collectionName] || primaryDefault;
+            for (const [tokenName, tokenData] of Object.entries(fileTokens)) {
+                const entry = tokenData;
+                if (entry.values[mode] === undefined)
+                    continue;
+                const defValue = resolveValue(entry.values[defMode] ?? Object.values(entry.values)[0], files, defMode, defaultModes);
+                const modeValue = resolveValue(entry.values[mode], files, mode, defaultModes);
+                if (modeValue && modeValue !== defValue) {
+                    const cssName = tokenNameToCSS(filePath, tokenName);
+                    overrides.push(`  --${cssName}: ${modeValue};`);
+                }
+            }
+        }
+        if (overrides.length > 0) {
+            output.push("");
+            const selector = mode.toLowerCase().replace(/\s+/g, "-");
+            output.push(`[data-theme="${selector}"] {`);
+            output.push(...overrides);
+            output.push("}");
+        }
+    }
+    return `${output.join("\n")}\n`;
+}
+export function exportSCSS(tokens) {
+    const { files } = tokens;
+    const { defaultModes, sortedModes, primaryDefault } = buildDefaultModes(tokens);
+    const output = [];
+    output.push("// Generated by StyleFlow");
+    output.push("// https://styleflow.app");
+    output.push("");
+    output.push("// Token variables");
+    output.push("");
+    for (const [filePath, fileTokens] of Object.entries(files)) {
+        const collectionName = filePath.split("/")[0];
+        const defMode = defaultModes[collectionName] || primaryDefault;
+        for (const [tokenName, tokenData] of Object.entries(fileTokens)) {
+            const entry = tokenData;
+            const name = tokenNameToCSS(filePath, tokenName);
+            const raw = entry.values[defMode] ?? Object.values(entry.values)[0];
+            const value = resolveValue(raw, files, defMode, defaultModes);
+            if (value) {
+                output.push(`$${name}: ${value};`);
+            }
+        }
+    }
+    for (const mode of sortedModes) {
+        const mapName = mode.toLowerCase().replace(/\s+/g, "-");
+        output.push("");
+        output.push(`$tokens-${mapName}: (`);
+        for (const [filePath, fileTokens] of Object.entries(files)) {
+            for (const [tokenName, tokenData] of Object.entries(fileTokens)) {
+                const entry = tokenData;
+                if (entry.values[mode] === undefined)
+                    continue;
+                const key = tokenNameToCSS(filePath, tokenName);
+                const value = resolveValue(entry.values[mode], files, mode, defaultModes);
+                if (value) {
+                    output.push(`  "${key}": ${value},`);
+                }
+            }
+        }
+        output.push(");");
+    }
+    return `${output.join("\n")}\n`;
+}
+export function exportStyleDictionary(tokens) {
+    const { files } = tokens;
+    const { defaultModes, primaryDefault } = buildDefaultModes(tokens);
+    const result = {};
+    for (const [filePath, fileTokens] of Object.entries(files)) {
+        const collectionName = filePath.split("/")[0];
+        const defMode = defaultModes[collectionName] || primaryDefault;
+        for (const [tokenName, tokenData] of Object.entries(fileTokens)) {
+            const entry = tokenData;
+            const raw = entry.values[defMode] ?? Object.values(entry.values)[0];
+            const value = resolveValue(raw, files, defMode, defaultModes);
+            if (!value)
+                continue;
+            const pathParts = tokenNameToSD(filePath, tokenName);
+            let current = result;
+            for (let i = 0; i < pathParts.length - 1; i++) {
+                const key = pathParts[i];
+                if (!current[key] || typeof current[key] !== "object") {
+                    current[key] = {};
+                }
+                current = current[key];
+            }
+            const lastKey = pathParts[pathParts.length - 1];
+            let sdType = "other";
+            if (entry.type === "COLOR")
+                sdType = "color";
+            else if (entry.type === "FLOAT" || entry.type === "NUMBER")
+                sdType = "number";
+            else if (entry.type === "BOOLEAN")
+                sdType = "boolean";
+            else if (entry.type === "STRING")
+                sdType = "string";
+            current[lastKey] = {
+                value,
+                type: sdType,
+            };
+        }
+    }
+    return result;
+}
+export function exportTailwindPreset(tokens) {
+    const { files } = tokens;
+    const { defaultModes, primaryDefault } = buildDefaultModes(tokens);
+    const colors = {};
+    for (const [filePath, fileTokens] of Object.entries(files)) {
+        const collectionName = filePath.split("/")[0];
+        const defMode = defaultModes[collectionName] || primaryDefault;
+        for (const [tokenName, tokenData] of Object.entries(fileTokens)) {
+            const entry = tokenData;
+            if (entry.type !== "COLOR")
+                continue;
+            const raw = entry.values[defMode] ?? Object.values(entry.values)[0];
+            const value = resolveValue(raw, files, defMode, defaultModes);
+            if (!value)
+                continue;
+            const key = tokenNameToCSS(filePath, tokenName);
+            colors[key] = value;
+        }
+    }
+    const output = [];
+    output.push("/** Generated by StyleFlow */");
+    output.push("/** https://styleflow.app */");
+    output.push("module.exports = {");
+    output.push("  theme: {");
+    output.push("    extend: {");
+    output.push("      colors: {");
+    for (const [key, value] of Object.entries(colors).sort(([a], [b]) => a.localeCompare(b))) {
+        output.push(`        ${JSON.stringify(key)}: ${JSON.stringify(value)},`);
+    }
+    output.push("      },");
+    output.push("    },");
+    output.push("  },");
+    output.push("};");
+    return `${output.join("\n")}\n`;
+}

package/dist/http.d.ts

@@ -0,0 +1,13 @@
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly path: string;
+    readonly bodyText: string;
+    constructor(path: string, status: number, bodyText: string);
+}
+export declare function apiGetJson<T>(params: {
+    baseUrl: string;
+    token: string;
+    path: string;
+    query?: Record<string, string | null | undefined>;
+}): Promise<T>;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAO3D;AAQD,wBAAsB,UAAU,CAAC,CAAC,EAChC,MAAM,EAAE;IACN,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CACnD,GACA,OAAO,CAAC,CAAC,CAAC,CAqBZ"}

package/dist/http.js

@@ -0,0 +1,37 @@
+export class ApiError extends Error {
+    status;
+    path;
+    bodyText;
+    constructor(path, status, bodyText) {
+        super(`Request failed (${status}) for ${path}`);
+        this.name = "ApiError";
+        this.status = status;
+        this.path = path;
+        this.bodyText = bodyText;
+    }
+}
+function joinUrl(baseUrl, requestPath) {
+    const cleanBase = baseUrl.replace(/\/+$/, "");
+    const cleanPath = requestPath.startsWith("/") ? requestPath : `/${requestPath}`;
+    return `${cleanBase}${cleanPath}`;
+}
+export async function apiGetJson(params) {
+    const url = new URL(joinUrl(params.baseUrl, params.path));
+    for (const [key, value] of Object.entries(params.query || {})) {
+        if (typeof value !== "string" || value.trim().length === 0)
+            continue;
+        url.searchParams.set(key, value.trim());
+    }
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${params.token}`,
+            Accept: "application/json",
+        },
+    });
+    if (!response.ok) {
+        const bodyText = await response.text();
+        throw new ApiError(params.path, response.status, bodyText);
+    }
+    return (await response.json());
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { StyleflowConfig } from "./types.js";
+export declare function defineConfig(config: StyleflowConfig): StyleflowConfig;
+export type { CollectionMeta, ComponentsOutputConfig, JsonOutputConfig, LoadedStyleflowConfig, PullResource, ResolvedStyleflowRuntimeConfig, StructuredTokens, StyleflowAuthConfig, StyleflowConfig, StyleflowMappingConfig, StyleflowOutputConfig, TokenEntry, TokenOutputConfig, TokenOutputFormat, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAErE;AAED,YAAY,EACV,cAAc,EACd,sBAAsB,EACtB,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,EACZ,8BAA8B,EAC9B,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,UAAU,EACV,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+    return config;
+}

package/dist/pull.d.ts

@@ -0,0 +1,19 @@
+import type { PullResource, ResolvedStyleflowRuntimeConfig } from "./types.js";
+type PulledResourceMeta = {
+    path: string;
+    hash: string | null;
+    version: number | null;
+    pulled: boolean;
+};
+export type PullResult = {
+    rawDirectory: string;
+    pulledResources: PullResource[];
+    skippedResources: PullResource[];
+    warnings: string[];
+    files: Record<PullResource, PulledResourceMeta>;
+    manifestPath: string;
+};
+export declare function normalizePullResources(input?: string | null): PullResource[];
+export declare function pullStyleflowData(runtime: ResolvedStyleflowRuntimeConfig, resources: PullResource[]): Promise<PullResult>;
+export {};
+//# sourceMappingURL=pull.d.ts.map

package/dist/pull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../src/pull.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAE/E,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,YAAY,EAAE,CAAC;IAChC,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;IAChD,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAQF,wBAAgB,sBAAsB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,YAAY,EAAE,CAa5E;AAQD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,8BAA8B,EACvC,SAAS,EAAE,YAAY,EAAE,GACxB,OAAO,CAAC,UAAU,CAAC,CAmIrB"}

package/dist/pull.js

@@ -0,0 +1,145 @@
+import path from "node:path";
+import { writeJsonFile } from "./fs.js";
+import { ApiError, apiGetJson } from "./http.js";
+export function normalizePullResources(input) {
+    const normalized = String(input || "all").trim().toLowerCase();
+    if (!normalized || normalized === "all") {
+        return ["tokens", "stylesheet", "figmaStyles"];
+    }
+    if (normalized === "tokens")
+        return ["tokens"];
+    if (normalized === "stylesheet")
+        return ["stylesheet"];
+    if (normalized === "figma-styles" || normalized === "figmastyles")
+        return ["figmaStyles"];
+    throw new Error(`Unknown resource "${input}". Use one of: all, tokens, stylesheet, figma-styles.`);
+}
+function toQuery(projectVersionId) {
+    return {
+        projectVersionId,
+    };
+}
+export async function pullStyleflowData(runtime, resources) {
+    const rawDirectory = path.resolve(runtime.cwd, runtime.rawDirectory);
+    const warnings = [];
+    const projectParam = encodeURIComponent(runtime.projectId);
+    const files = {
+        tokens: {
+            path: path.join(rawDirectory, "tokens.structured.json"),
+            hash: null,
+            version: null,
+            pulled: false,
+        },
+        stylesheet: {
+            path: path.join(rawDirectory, "stylesheet.json"),
+            hash: null,
+            version: null,
+            pulled: false,
+        },
+        figmaStyles: {
+            path: path.join(rawDirectory, "figma-styles.json"),
+            hash: null,
+            version: null,
+            pulled: false,
+        },
+    };
+    const requested = new Set(resources);
+    if (requested.has("tokens")) {
+        const payload = await apiGetJson({
+            baseUrl: runtime.apiUrl,
+            token: runtime.token,
+            path: `/api/styleflow/projects/${projectParam}/tokens`,
+            query: {
+                ...toQuery(runtime.projectVersionId),
+                format: "structured",
+            },
+        });
+        if (!payload || typeof payload.tokens !== "object" || payload.tokens === null) {
+            throw new Error("Tokens endpoint returned an empty payload.");
+        }
+        await writeJsonFile(files.tokens.path, payload.tokens);
+        files.tokens.pulled = true;
+    }
+    if (requested.has("stylesheet")) {
+        try {
+            const payload = await apiGetJson({
+                baseUrl: runtime.apiUrl,
+                token: runtime.token,
+                path: `/api/styleflow/projects/${projectParam}/stylesheet`,
+                query: toQuery(runtime.projectVersionId),
+            });
+            await writeJsonFile(files.stylesheet.path, payload.data ?? {});
+            files.stylesheet.hash = typeof payload.hash === "string" ? payload.hash : null;
+            files.stylesheet.version =
+                typeof payload.version === "number" ? payload.version : null;
+            files.stylesheet.pulled = true;
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 404) {
+                warnings.push("Stylesheet not found for project/version. Skipped.");
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    if (requested.has("figmaStyles")) {
+        try {
+            const payload = await apiGetJson({
+                baseUrl: runtime.apiUrl,
+                token: runtime.token,
+                path: `/api/styleflow/projects/${projectParam}/figma-styles`,
+                query: toQuery(runtime.projectVersionId),
+            });
+            await writeJsonFile(files.figmaStyles.path, payload.data ?? {});
+            files.figmaStyles.hash = typeof payload.hash === "string" ? payload.hash : null;
+            files.figmaStyles.version =
+                typeof payload.version === "number" ? payload.version : null;
+            files.figmaStyles.pulled = true;
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 404) {
+                warnings.push("Figma styles not found for project/version. Skipped.");
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    const manifestPath = path.join(rawDirectory, "manifest.json");
+    await writeJsonFile(manifestPath, {
+        schemaVersion: 1,
+        pulledAt: new Date().toISOString(),
+        apiUrl: runtime.apiUrl,
+        projectId: runtime.projectId,
+        projectVersionId: runtime.projectVersionId,
+        resources: {
+            tokens: {
+                path: path.relative(rawDirectory, files.tokens.path),
+                pulled: files.tokens.pulled,
+            },
+            stylesheet: {
+                path: path.relative(rawDirectory, files.stylesheet.path),
+                pulled: files.stylesheet.pulled,
+                hash: files.stylesheet.hash,
+                version: files.stylesheet.version,
+            },
+            figmaStyles: {
+                path: path.relative(rawDirectory, files.figmaStyles.path),
+                pulled: files.figmaStyles.pulled,
+                hash: files.figmaStyles.hash,
+                version: files.figmaStyles.version,
+            },
+        },
+    });
+    const pulledResources = resources.filter((resource) => files[resource].pulled);
+    const skippedResources = resources.filter((resource) => !files[resource].pulled);
+    return {
+        rawDirectory,
+        pulledResources,
+        skippedResources,
+        warnings,
+        files,
+        manifestPath,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,68 @@
+export type PullResource = "tokens" | "stylesheet" | "figmaStyles";
+export type TokenOutputFormat = "css" | "scss" | "json" | "style-dictionary" | "tailwind";
+export interface TokenOutputConfig {
+    format?: TokenOutputFormat;
+    path: string;
+}
+export interface JsonOutputConfig {
+    format?: "json";
+    path: string;
+}
+export interface ComponentsOutputConfig {
+    path: string;
+    framework?: "react" | "vue" | "svelte" | "html";
+    styling?: "tailwind" | "css-modules" | "styled-components";
+}
+export interface StyleflowOutputConfig {
+    language?: "typescript" | "javascript";
+    tokens?: TokenOutputConfig;
+    stylesheet?: JsonOutputConfig;
+    figmaStyles?: JsonOutputConfig;
+    components?: ComponentsOutputConfig;
+}
+export interface StyleflowMappingConfig {
+    classes?: Record<string, string>;
+    tokens?: Record<string, string>;
+}
+export interface StyleflowAuthConfig {
+    token?: string;
+}
+export interface StyleflowConfig {
+    projectId?: string;
+    projectVersionId?: string | null;
+    apiUrl?: string;
+    rawDirectory?: string;
+    auth?: StyleflowAuthConfig;
+    output?: StyleflowOutputConfig;
+    mapping?: StyleflowMappingConfig;
+}
+export interface LoadedStyleflowConfig {
+    config: StyleflowConfig;
+    configPath: string | null;
+    cwd: string;
+}
+export interface ResolvedStyleflowRuntimeConfig {
+    cwd: string;
+    projectId: string;
+    projectVersionId: string | null;
+    apiUrl: string;
+    token: string;
+    rawDirectory: string;
+    config: StyleflowConfig;
+    configPath: string | null;
+}
+export type TokenEntry = {
+    type: string;
+    values: Record<string, unknown>;
+};
+export type CollectionMeta = {
+    id?: string;
+    name: string;
+    defaultMode: string;
+    modes: string[];
+};
+export type StructuredTokens = {
+    files: Record<string, Record<string, TokenEntry>>;
+    collections: Record<string, CollectionMeta>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,YAAY,GAAG,aAAa,CAAC;AAEnE,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,UAAU,CAAC;AAE1F,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAChD,OAAO,CAAC,EAAE,UAAU,GAAG,aAAa,GAAG,mBAAmB,CAAC;CAC5D;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,UAAU,CAAC,EAAE,sBAAsB,CAAC;CACrC;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B,OAAO,CAAC,EAAE,sBAAsB,CAAC;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,8BAA8B;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IAClD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC7C,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "styleflow",
+  "version": "0.1.0",
+  "description": "StyleFlow design-to-dev CLI for pulling and building tokens/stylesheets",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "styleflow": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "design-tokens",
+    "figma",
+    "styleflow",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "jiti": "^2.4.2"
+  },
+  "license": "MIT"
+}