@promptui-lib/cli 0.1.0

package/bin/promptui.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { run } from '../dist/index.js';
+
+run().catch((error) => {
+  console.error('[PromptUI] Error:', error.message);
+  process.exit(1);
+});

package/dist/commands/generate.cmd.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generate Command
+ * Gera componente a partir de um node do Figma ou arquivo JSON local
+ */
+import type { ComponentLayer, FrameworkType } from '@promptui-lib/core';
+export interface IGenerateOptions {
+    force?: boolean;
+    output?: string;
+    layer?: ComponentLayer;
+    framework?: FrameworkType;
+    preview?: boolean;
+    noMeta?: boolean;
+}
+export declare function generateCommand(input: string, options: IGenerateOptions): Promise<void>;
+/**
+ * Gera todos os componentes marcados com # no arquivo Figma
+ */
+export declare function generateAllCommand(options: IGenerateOptions): Promise<void>;
+//# sourceMappingURL=generate.cmd.d.ts.map

package/dist/commands/generate.cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.cmd.d.ts","sourceRoot":"","sources":["../../src/commands/generate.cmd.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAc,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAapF,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AA0ED,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,IAAI,CAAC,CAqJf;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgFjF"}

package/dist/commands/generate.cmd.js

@@ -0,0 +1,261 @@
+/**
+ * Generate Command
+ * Gera componente a partir de um node do Figma ou arquivo JSON local
+ */
+import { readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { createFigmaClient } from '@promptui-lib/figma-parser';
+import { parseNode } from '@promptui-lib/figma-parser';
+import { writeComponent, generateCode, generateMuiComponent, generateTailwindComponent, generateBootstrapComponent, FRAMEWORKS, } from '@promptui-lib/codegen';
+import { loadConfig, resolveConfig, validateConfig } from '@promptui-lib/mcp-agent';
+/**
+ * Detecta se o input é um arquivo JSON local ou nodeId do Figma
+ */
+function isLocalFile(input) {
+    return input.endsWith('.json') || input.startsWith('./') || input.startsWith('/');
+}
+/**
+ * Carrega node de arquivo JSON local
+ */
+async function loadNodeFromFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    const node = JSON.parse(content);
+    if (!node.id || !node.name || !node.type) {
+        throw new Error('Invalid Figma node JSON: missing id, name or type');
+    }
+    return node;
+}
+/**
+ * Gera metadados do componente
+ */
+function generateMeta(node, ast, source, files) {
+    const content = JSON.stringify({ node, ast, source, files });
+    const checksum = createHash('sha256').update(content).digest('hex');
+    return {
+        generator: 'promptui-figma-codegen',
+        version: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        source: {
+            nodeId: node.id,
+            nodeName: node.name,
+            fileId: source.fileId,
+            fromFile: source.fromFile,
+        },
+        output: {
+            componentName: ast.name,
+            fileName: ast.fileName,
+            layer: ast.layer,
+            files,
+        },
+        checksum: `sha256:${checksum}`,
+    };
+}
+export async function generateCommand(input, options) {
+    const isFile = isLocalFile(input);
+    console.log(`[PromptUI] Generating component from ${isFile ? 'file' : 'Figma node'}: ${input}`);
+    // Carrega config
+    const config = await loadConfig();
+    const resolved = resolveConfig(config);
+    let node;
+    let sourceInfo = {};
+    try {
+        if (isFile) {
+            // Carrega de arquivo JSON local
+            node = await loadNodeFromFile(input);
+            sourceInfo.fromFile = input;
+            console.log(`[PromptUI] Loaded from file: ${node.name} (${node.type})`);
+        }
+        else {
+            // Valida config para API
+            const errors = validateConfig(resolved);
+            if (errors.length > 0) {
+                console.error('[PromptUI] Configuration errors:');
+                for (const error of errors) {
+                    console.error(`  - ${error}`);
+                }
+                process.exit(1);
+            }
+            // Busca node do Figma
+            const client = createFigmaClient({ token: resolved.figmaToken });
+            const fetchedNode = await client.getNode(resolved.figmaFileId, input);
+            if (!fetchedNode) {
+                console.error(`[PromptUI] Node not found: ${input}`);
+                process.exit(1);
+            }
+            node = fetchedNode;
+            sourceInfo.fileId = resolved.figmaFileId;
+            console.log(`[PromptUI] Fetched from Figma: ${node.name} (${node.type})`);
+        }
+        // Parseia
+        const ast = parseNode(node, { forceLayer: options.layer });
+        const framework = options.framework ?? 'react';
+        const frameworkInfo = FRAMEWORKS[framework];
+        console.log(`[PromptUI] Parsed: ${ast.name} (${ast.layer})`);
+        console.log(`[PromptUI] Framework: ${frameworkInfo?.displayName ?? framework}`);
+        // Gera código baseado no framework
+        const generateForFramework = () => {
+            switch (framework) {
+                case 'mui':
+                    return {
+                        tsx: generateMuiComponent(ast),
+                        scss: '', // MUI usa sx props inline
+                        index: `export { ${ast.name} } from './${ast.fileName}';\nexport type { I${ast.name}Props } from './${ast.fileName}';\n`,
+                    };
+                case 'tailwind':
+                    return {
+                        tsx: generateTailwindComponent(ast),
+                        scss: '', // Tailwind usa classes inline
+                        index: `export { ${ast.name} } from './${ast.fileName}';\nexport type { I${ast.name}Props } from './${ast.fileName}';\n`,
+                    };
+                case 'bootstrap':
+                    return {
+                        tsx: generateBootstrapComponent(ast),
+                        scss: '', // Bootstrap usa classes inline
+                        index: `export { ${ast.name} } from './${ast.fileName}';\nexport type { I${ast.name}Props } from './${ast.fileName}';\n`,
+                    };
+                case 'react':
+                default:
+                    return generateCode(ast);
+            }
+        };
+        // Preview mode
+        if (options.preview) {
+            const code = generateForFramework();
+            console.log('\n--- TSX ---');
+            console.log(code.tsx);
+            if (code.scss) {
+                console.log('\n--- SCSS ---');
+                console.log(code.scss);
+            }
+            console.log('\n--- index.ts ---');
+            console.log(code.index);
+            if (!options.noMeta) {
+                const meta = generateMeta(node, ast, sourceInfo, [
+                    `${ast.fileName}.tsx`,
+                    `${ast.fileName}.scss`,
+                    'index.ts',
+                    'meta.json',
+                ]);
+                console.log('\n--- meta.json ---');
+                console.log(JSON.stringify(meta, null, 2));
+            }
+            return;
+        }
+        // Escreve arquivos
+        const basePath = options.output ?? resolved.outputBasePath;
+        const result = await writeComponent(ast, {
+            basePath,
+            forceOverwrite: options.force,
+        });
+        if (!result.success) {
+            console.error('[PromptUI] Failed to write files:');
+            for (const error of result.errors ?? []) {
+                console.error(`  - ${error}`);
+            }
+            process.exit(1);
+        }
+        // Gera meta.json
+        if (!options.noMeta) {
+            const { writeFile } = await import('node:fs/promises');
+            const { join, dirname } = await import('node:path');
+            const metaPath = join(dirname(result.files.tsx), 'meta.json');
+            const meta = generateMeta(node, ast, sourceInfo, [
+                `${ast.fileName}.tsx`,
+                `${ast.fileName}.scss`,
+                'index.ts',
+                'meta.json',
+            ]);
+            await writeFile(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+            console.log('[PromptUI] Generated files:');
+            console.log(`  - ${result.files.tsx}`);
+            console.log(`  - ${result.files.scss}`);
+            console.log(`  - ${result.files.index}`);
+            console.log(`  - ${metaPath}`);
+        }
+        else {
+            console.log('[PromptUI] Generated files:');
+            console.log(`  - ${result.files.tsx}`);
+            console.log(`  - ${result.files.scss}`);
+            console.log(`  - ${result.files.index}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`[PromptUI] Error: ${message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Gera todos os componentes marcados com # no arquivo Figma
+ */
+export async function generateAllCommand(options) {
+    console.log('[PromptUI] Generating all exportable components...');
+    // Carrega config
+    const config = await loadConfig();
+    const resolved = resolveConfig(config);
+    // Valida
+    const errors = validateConfig(resolved);
+    if (errors.length > 0) {
+        console.error('[PromptUI] Configuration errors:');
+        for (const error of errors) {
+            console.error(`  - ${error}`);
+        }
+        process.exit(1);
+    }
+    try {
+        const client = createFigmaClient({ token: resolved.figmaToken });
+        const file = await client.getFile(resolved.figmaFileId);
+        // Encontra todos os nodes exportáveis (começam com #)
+        const exportableNodes = [];
+        function findExportable(node) {
+            if (node.name.startsWith('#')) {
+                exportableNodes.push(node);
+            }
+            if (node.children) {
+                for (const child of node.children) {
+                    findExportable(child);
+                }
+            }
+        }
+        if (file.document) {
+            findExportable(file.document);
+        }
+        console.log(`[PromptUI] Found ${exportableNodes.length} exportable components`);
+        if (exportableNodes.length === 0) {
+            console.log('[PromptUI] No components found. Mark frames with # prefix to export.');
+            return;
+        }
+        let successCount = 0;
+        let errorCount = 0;
+        for (const node of exportableNodes) {
+            try {
+                const ast = parseNode(node, { forceLayer: options.layer });
+                const basePath = options.output ?? resolved.outputBasePath;
+                const result = await writeComponent(ast, {
+                    basePath,
+                    forceOverwrite: options.force,
+                });
+                if (result.success) {
+                    console.log(`  ✅ ${ast.name} (${ast.layer})`);
+                    successCount++;
+                }
+                else {
+                    console.log(`  ❌ ${node.name}: ${result.errors?.join(', ')}`);
+                    errorCount++;
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                console.log(`  ❌ ${node.name}: ${message}`);
+                errorCount++;
+            }
+        }
+        console.log('');
+        console.log(`[PromptUI] Done: ${successCount} success, ${errorCount} errors`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`[PromptUI] Error: ${message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,8 @@
+export { generateCommand, generateAllCommand } from './generate.cmd.js';
+export type { IGenerateOptions } from './generate.cmd.js';
+export { initCommand } from './init.cmd.js';
+export { syncTokensCommand } from './sync.cmd.js';
+export type { ISyncOptions } from './sync.cmd.js';
+export { mcpCommand, studioCommand, listAgents } from './mcp.cmd.js';
+export type { IMcpOptions } from './mcp.cmd.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACxE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC"}

package/dist/commands/index.js

@@ -0,0 +1,4 @@
+export { generateCommand, generateAllCommand } from './generate.cmd.js';
+export { initCommand } from './init.cmd.js';
+export { syncTokensCommand } from './sync.cmd.js';
+export { mcpCommand, studioCommand, listAgents } from './mcp.cmd.js';

package/dist/commands/init.cmd.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Init Command
+ * Cria arquivo de configuração inicial
+ */
+export declare function initCommand(): Promise<void>;
+//# sourceMappingURL=init.cmd.d.ts.map

package/dist/commands/init.cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.cmd.d.ts","sourceRoot":"","sources":["../../src/commands/init.cmd.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgBH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CA8BjD"}

package/dist/commands/init.cmd.js

@@ -0,0 +1,45 @@
+/**
+ * Init Command
+ * Cria arquivo de configuração inicial
+ */
+import { writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
+const DEFAULT_CONFIG = {
+    figma: {
+        token: 'YOUR_FIGMA_TOKEN',
+        fileId: 'YOUR_FILE_ID',
+    },
+    output: {
+        basePath: 'src/components',
+        styleFormat: 'scss',
+    },
+};
+export async function initCommand() {
+    const configPath = join(process.cwd(), 'promptui.config.json');
+    // Verifica se já existe
+    try {
+        await access(configPath);
+        console.log('[PromptUI] Config file already exists: promptui.config.json');
+        console.log('[PromptUI] Delete it first if you want to reinitialize.');
+        return;
+    }
+    catch {
+        // Arquivo não existe, podemos criar
+    }
+    // Escreve config
+    const content = JSON.stringify(DEFAULT_CONFIG, null, 2);
+    await writeFile(configPath, content, 'utf-8');
+    console.log('[PromptUI] Created: promptui.config.json');
+    console.log('');
+    console.log('Next steps:');
+    console.log('  1. Get your Figma Personal Access Token:');
+    console.log('     https://www.figma.com/developers/api#access-tokens');
+    console.log('');
+    console.log('  2. Get your Figma File ID from the URL:');
+    console.log('     https://www.figma.com/file/<FILE_ID>/...');
+    console.log('');
+    console.log('  3. Update promptui.config.json with your values');
+    console.log('');
+    console.log('  4. Start the agent:');
+    console.log('     npx promptui agent');
+}

package/dist/commands/mcp.cmd.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MCP Command
+ * Executa agentes MCP do PromptUI
+ */
+export interface IMcpOptions {
+    input?: string;
+    output?: string;
+    preview?: boolean;
+}
+/**
+ * Lista agentes disponíveis
+ */
+export declare function listAgents(): void;
+/**
+ * Executa um agente MCP
+ */
+export declare function mcpCommand(agentKey: string, input: string, options: IMcpOptions): Promise<void>;
+/**
+ * Inicia o PromptUI Studio (interface interativa)
+ */
+export declare function studioCommand(): Promise<void>;
+//# sourceMappingURL=mcp.cmd.d.ts.map

package/dist/commands/mcp.cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.cmd.d.ts","sourceRoot":"","sources":["../../src/commands/mcp.cmd.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAUD;;GAEG;AACH,wBAAgB,UAAU,IAAI,IAAI,CASjC;AAyBD;;GAEG;AACH,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAoDf;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAsBnD"}

package/dist/commands/mcp.cmd.js

@@ -0,0 +1,120 @@
+/**
+ * MCP Command
+ * Executa agentes MCP do PromptUI
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const AVAILABLE_AGENTS = {
+    'figma-codegen': {
+        name: 'promptui-figma-codegen',
+        description: 'Gera componentes React a partir de JSON do Figma (100% determinístico)',
+        promptFile: '.claude/agents/promptui-figma-codegen.md',
+    },
+};
+/**
+ * Lista agentes disponíveis
+ */
+export function listAgents() {
+    console.log('[PromptUI] Available MCP Agents:\n');
+    for (const [key, agent] of Object.entries(AVAILABLE_AGENTS)) {
+        console.log(`  ${key}`);
+        console.log(`    ${agent.description}`);
+        console.log(`    Usage: npx promptui mcp ${key} <input>`);
+        console.log('');
+    }
+}
+/**
+ * Carrega o prompt de um agente
+ */
+async function loadAgentPrompt(agentKey) {
+    const agent = AVAILABLE_AGENTS[agentKey];
+    if (!agent) {
+        throw new Error(`Unknown agent: ${agentKey}. Use 'npx promptui mcp' to list available agents.`);
+    }
+    const promptPath = join(process.cwd(), agent.promptFile);
+    try {
+        return await readFile(promptPath, 'utf-8');
+    }
+    catch {
+        // Se não encontrar no projeto, tenta no pacote
+        throw new Error(`Agent prompt not found: ${promptPath}\n` +
+            `Make sure the PromptUI agents are configured in your project.`);
+    }
+}
+/**
+ * Executa um agente MCP
+ */
+export async function mcpCommand(agentKey, input, options) {
+    if (!agentKey) {
+        listAgents();
+        return;
+    }
+    console.log(`[PromptUI] Running MCP agent: ${agentKey}`);
+    try {
+        // Carrega o prompt do agente
+        const prompt = await loadAgentPrompt(agentKey);
+        console.log(`[PromptUI] Agent loaded: ${AVAILABLE_AGENTS[agentKey]?.name}`);
+        // Para o agente figma-codegen, precisamos do input
+        if (agentKey === 'figma-codegen') {
+            if (!input) {
+                console.error('[PromptUI] Error: Missing input (nodeId or JSON file path)');
+                console.log('Usage: npx promptui mcp figma-codegen <nodeId | file.json>');
+                process.exit(1);
+            }
+            // Aqui seria a integração com o MCP SDK
+            // Por enquanto, mostra as instruções
+            console.log('');
+            console.log('[PromptUI] MCP Agent Instructions:');
+            console.log('');
+            console.log('To use this agent with Claude:');
+            console.log('');
+            console.log('1. Start the MCP server:');
+            console.log('   npx promptui agent');
+            console.log('');
+            console.log('2. Connect via MCP client or use the HTTP API:');
+            console.log('   curl -X POST http://localhost:17890/generate \\');
+            console.log('     -H "Content-Type: application/json" \\');
+            console.log(`     -d '{"nodeId": "${input}"}'`);
+            console.log('');
+            console.log('3. Or use the generate command directly:');
+            console.log(`   npx promptui generate ${input}`);
+            console.log('');
+            if (options.preview) {
+                console.log('--- Agent Prompt Preview ---');
+                console.log(prompt.substring(0, 2000) + '...');
+                console.log('--- End Preview ---');
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`[PromptUI] Error: ${message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Inicia o PromptUI Studio (interface interativa)
+ */
+export async function studioCommand() {
+    console.log('[PromptUI] Starting PromptUI Studio...');
+    console.log('');
+    console.log('╔════════════════════════════════════════════════════════╗');
+    console.log('║               PromptUI Studio (Preview)                 ║');
+    console.log('╠════════════════════════════════════════════════════════╣');
+    console.log('║                                                         ║');
+    console.log('║  This feature is coming soon!                           ║');
+    console.log('║                                                         ║');
+    console.log('║  PromptUI Studio will provide:                          ║');
+    console.log('║  - Interactive component generation                     ║');
+    console.log('║  - Visual preview of generated components               ║');
+    console.log('║  - Token management and sync                            ║');
+    console.log('║  - Claude AI integration for suggestions                ║');
+    console.log('║                                                         ║');
+    console.log('║  For now, use the CLI commands:                         ║');
+    console.log('║  - npx promptui generate <nodeId>                       ║');
+    console.log('║  - npx promptui generate all                            ║');
+    console.log('║  - npx promptui sync tokens                             ║');
+    console.log('║                                                         ║');
+    console.log('╚════════════════════════════════════════════════════════╝');
+    console.log('');
+}

package/dist/commands/sync.cmd.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sync Command
+ * Sincroniza tokens do Figma para o projeto local
+ */
+export interface ISyncOptions {
+    output?: string;
+}
+export declare function syncTokensCommand(options: ISyncOptions): Promise<void>;
+//# sourceMappingURL=sync.cmd.d.ts.map

package/dist/commands/sync.cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.cmd.d.ts","sourceRoot":"","sources":["../../src/commands/sync.cmd.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA+JD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAmH5E"}

package/dist/commands/sync.cmd.js

@@ -0,0 +1,214 @@
+/**
+ * Sync Command
+ * Sincroniza tokens do Figma para o projeto local
+ */
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createFigmaClient } from '@promptui-lib/figma-parser';
+import { loadConfig, resolveConfig, validateConfig } from '@promptui-lib/mcp-agent';
+/**
+ * Converte cor RGB (0-1) para hex
+ */
+function rgbToHex(color) {
+    const r = Math.round(color.r * 255).toString(16).padStart(2, '0');
+    const g = Math.round(color.g * 255).toString(16).padStart(2, '0');
+    const b = Math.round(color.b * 255).toString(16).padStart(2, '0');
+    return `#${r}${g}${b}`;
+}
+/**
+ * Converte nome do estilo para nome de variável SCSS
+ */
+function styleNameToVariable(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Gera arquivo SCSS de cores
+ */
+function generateColorsScss(colors) {
+    const lines = [
+        '// PromptUI - Color Tokens',
+        '// Auto-generated from Figma styles',
+        '// Do not edit manually',
+        '',
+    ];
+    for (const color of colors) {
+        const varName = `$color-${styleNameToVariable(color.name)}`;
+        lines.push(`${varName}: ${color.value};`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Gera arquivo SCSS de tipografia
+ */
+function generateTypographyScss(textStyles) {
+    const lines = [
+        '// PromptUI - Typography Tokens',
+        '// Auto-generated from Figma styles',
+        '// Do not edit manually',
+        '',
+    ];
+    // Agrupa por categoria
+    const fontFamilies = new Set();
+    const fontSizes = new Map();
+    const fontWeights = new Set();
+    for (const style of textStyles) {
+        fontFamilies.add(style.fontFamily);
+        fontSizes.set(style.fontSize, style.name);
+        fontWeights.add(style.fontWeight);
+    }
+    // Font families
+    lines.push('// Font Families');
+    let familyIndex = 1;
+    for (const family of fontFamilies) {
+        lines.push(`$font-family-${familyIndex}: "${family}", sans-serif;`);
+        familyIndex++;
+    }
+    lines.push('');
+    // Font sizes
+    lines.push('// Font Sizes');
+    const sortedSizes = Array.from(fontSizes.entries()).sort((a, b) => a[0] - b[0]);
+    for (const [size, name] of sortedSizes) {
+        const varName = `$font-size-${styleNameToVariable(name)}`;
+        lines.push(`${varName}: ${size}px;`);
+    }
+    lines.push('');
+    // Font weights
+    lines.push('// Font Weights');
+    const weightNames = {
+        100: 'thin',
+        200: 'extralight',
+        300: 'light',
+        400: 'regular',
+        500: 'medium',
+        600: 'semibold',
+        700: 'bold',
+        800: 'extrabold',
+        900: 'black',
+    };
+    const sortedWeights = Array.from(fontWeights).sort((a, b) => a - b);
+    for (const weight of sortedWeights) {
+        const name = weightNames[weight] ?? `w${weight}`;
+        lines.push(`$font-weight-${name}: ${weight};`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Gera arquivo SCSS de efeitos (shadows)
+ */
+function generateEffectsScss(effects) {
+    const lines = [
+        '// PromptUI - Effect Tokens',
+        '// Auto-generated from Figma styles',
+        '// Do not edit manually',
+        '',
+        '// Shadows',
+    ];
+    for (const effect of effects) {
+        if (effect.type === 'DROP_SHADOW' && effect.color) {
+            const varName = `$shadow-${styleNameToVariable(effect.name)}`;
+            const x = effect.offset?.x ?? 0;
+            const y = effect.offset?.y ?? 0;
+            const blur = effect.radius ?? 0;
+            const color = `rgba(${Math.round(effect.color.r * 255)}, ${Math.round(effect.color.g * 255)}, ${Math.round(effect.color.b * 255)}, ${effect.color.a.toFixed(2)})`;
+            lines.push(`${varName}: ${x}px ${y}px ${blur}px ${color};`);
+        }
+    }
+    return lines.join('\n');
+}
+export async function syncTokensCommand(options) {
+    console.log('[PromptUI] Syncing tokens from Figma...');
+    // Carrega config
+    const config = await loadConfig();
+    const resolved = resolveConfig(config);
+    // Valida
+    const errors = validateConfig(resolved);
+    if (errors.length > 0) {
+        console.error('[PromptUI] Configuration errors:');
+        for (const error of errors) {
+            console.error(`  - ${error}`);
+        }
+        process.exit(1);
+    }
+    try {
+        const client = createFigmaClient({ token: resolved.figmaToken });
+        console.log('[PromptUI] Fetching styles from Figma...');
+        const stylesRecord = await client.getStyles(resolved.figmaFileId);
+        if (!stylesRecord || Object.keys(stylesRecord).length === 0) {
+            console.log('[PromptUI] No styles found in the Figma file.');
+            return;
+        }
+        const stylesArray = Object.values(stylesRecord);
+        console.log(`[PromptUI] Found ${stylesArray.length} styles`);
+        // Separa por tipo
+        const colorStyles = [];
+        const textStyles = [];
+        const effectStyles = [];
+        for (const style of stylesArray) {
+            // Aqui precisaríamos buscar os detalhes de cada style
+            // Por enquanto, apenas categoriza
+            if (style.styleType === 'FILL') {
+                // Placeholder - precisaria buscar o node para ter a cor
+                colorStyles.push({
+                    name: style.name,
+                    value: '#000000', // Placeholder
+                });
+            }
+            else if (style.styleType === 'TEXT') {
+                textStyles.push({
+                    name: style.name,
+                    fontFamily: 'Inter',
+                    fontSize: 16,
+                    fontWeight: 400,
+                });
+            }
+            else if (style.styleType === 'EFFECT') {
+                effectStyles.push({
+                    name: style.name,
+                    type: 'DROP_SHADOW',
+                });
+            }
+        }
+        // Cria diretório de output
+        const outputDir = options.output ?? join(process.cwd(), 'src/styles/tokens');
+        await mkdir(outputDir, { recursive: true });
+        // Gera arquivos
+        if (colorStyles.length > 0) {
+            const colorsPath = join(outputDir, '_colors.scss');
+            await writeFile(colorsPath, generateColorsScss(colorStyles), 'utf-8');
+            console.log(`  ✅ Colors: ${colorsPath}`);
+        }
+        if (textStyles.length > 0) {
+            const typographyPath = join(outputDir, '_typography.scss');
+            await writeFile(typographyPath, generateTypographyScss(textStyles), 'utf-8');
+            console.log(`  ✅ Typography: ${typographyPath}`);
+        }
+        if (effectStyles.length > 0) {
+            const effectsPath = join(outputDir, '_effects.scss');
+            await writeFile(effectsPath, generateEffectsScss(effectStyles), 'utf-8');
+            console.log(`  ✅ Effects: ${effectsPath}`);
+        }
+        // Gera index
+        const indexPath = join(outputDir, '_index.scss');
+        const indexContent = [
+            '// PromptUI - Design Tokens',
+            '// Auto-generated from Figma',
+            '',
+            "@forward 'colors';",
+            "@forward 'typography';",
+            "@forward 'effects';",
+            '',
+        ].join('\n');
+        await writeFile(indexPath, indexContent, 'utf-8');
+        console.log(`  ✅ Index: ${indexPath}`);
+        console.log('');
+        console.log('[PromptUI] Tokens synced successfully!');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`[PromptUI] Error: ${message}`);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @promptui-lib/cli
+ * CLI for PromptUI - Figma to React code generator
+ */
+export declare function run(args?: string[]): Promise<void>;
+//# 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;;;GAGG;AAgEH,wBAAsB,GAAG,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAkH/E"}

package/dist/index.js

@@ -0,0 +1,169 @@
+/**
+ * @promptui-lib/cli
+ * CLI for PromptUI - Figma to React code generator
+ */
+import { parseArgs } from 'node:util';
+import { startAgent } from '@promptui-lib/mcp-agent';
+import { generateCommand, generateAllCommand } from './commands/generate.cmd.js';
+import { initCommand } from './commands/init.cmd.js';
+import { syncTokensCommand } from './commands/sync.cmd.js';
+import { mcpCommand, studioCommand, listAgents } from './commands/mcp.cmd.js';
+const HELP_TEXT = `
+PromptUI - Figma to React Code Generator
+
+Usage:
+  promptui <command> [options]
+
+Commands:
+  init                        Initialize configuration file
+  agent                       Start the MCP agent server
+  generate                    Generate all #marked components (React + SCSS)
+  generate mui                Generate all #marked components (Material UI)
+  generate tailwind           Generate all #marked components (Tailwind CSS)
+  generate bootstrap          Generate all #marked components (Bootstrap)
+  generate <nodeId>           Generate specific node by ID
+  generate <file.json>        Generate from local JSON file
+  sync tokens                 Sync design tokens from Figma
+  mcp <agent> [input]         Run MCP agent (use 'mcp' alone to list agents)
+  studio                      Start PromptUI Studio (interactive mode)
+
+Options:
+  --help, -h            Show this help message
+  --version, -v         Show version
+  --force, -f           Force overwrite existing files
+  --output, -o          Output directory
+  --layer, -l           Force layer (atoms|molecules|organisms)
+  --preview, -p         Preview output without writing files
+  --no-meta             Skip generating meta.json
+
+Frameworks:
+  react      React + SCSS with BEM methodology (default)
+  mui        Material UI with sx props and MUI components
+  tailwind   Tailwind CSS utility classes
+  bootstrap  Bootstrap CSS classes
+
+Examples:
+  promptui init                          # Create promptui.config.json
+  promptui agent                         # Start agent on port 17890
+  promptui generate                      # Generate all (React + SCSS)
+  promptui generate mui                  # Generate all (Material UI)
+  promptui generate tailwind             # Generate all (Tailwind CSS)
+  promptui generate bootstrap            # Generate all (Bootstrap)
+  promptui generate 123:456              # Generate specific node
+  promptui generate ./button.json        # Generate from local JSON
+  promptui generate ./button.json -p     # Preview without writing
+  promptui sync tokens                   # Sync tokens from Figma
+
+Environment Variables:
+  FIGMA_TOKEN           Figma personal access token
+  FIGMA_FILE_ID         Default Figma file ID
+  PROMPTUI_PORT         Agent port (default: 17890)
+  PROMPTUI_OUTPUT_PATH  Output path (default: src/components)
+`;
+const VERSION = '0.1.0';
+export async function run(args = process.argv.slice(2)) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: {
+            help: { type: 'boolean', short: 'h' },
+            version: { type: 'boolean', short: 'v' },
+            force: { type: 'boolean', short: 'f' },
+            output: { type: 'string', short: 'o' },
+            layer: { type: 'string', short: 'l' },
+            framework: { type: 'string', short: 'F' },
+            preview: { type: 'boolean', short: 'p' },
+            'no-meta': { type: 'boolean' },
+        },
+        allowPositionals: true,
+    });
+    // Version (check first, before help)
+    if (values.version) {
+        console.log(`promptui v${VERSION}`);
+        return;
+    }
+    // Help
+    if (values.help || positionals.length === 0) {
+        console.log(HELP_TEXT);
+        return;
+    }
+    const command = positionals[0];
+    switch (command) {
+        // promptui init
+        case 'init':
+            await initCommand();
+            break;
+        // promptui agent
+        case 'agent':
+            await startAgent();
+            break;
+        // promptui generate [framework|nodeId|file.json]
+        case 'generate': {
+            const input = positionals[1];
+            const FRAMEWORKS = ['react', 'mui', 'tailwind', 'bootstrap'];
+            // Detecta se o input é um framework
+            const isFramework = input && FRAMEWORKS.includes(input);
+            // Se não tem input ou é um framework, gera todos os componentes
+            const generateAll = !input || isFramework;
+            // Define o framework (do input ou do flag)
+            const framework = isFramework
+                ? input
+                : values.framework;
+            const generateOptions = {
+                force: values.force,
+                output: values.output,
+                layer: values.layer,
+                framework,
+                preview: values.preview,
+                noMeta: values['no-meta'],
+            };
+            if (generateAll) {
+                await generateAllCommand(generateOptions);
+            }
+            else {
+                await generateCommand(input, generateOptions);
+            }
+            break;
+        }
+        // promptui sync <subcommand>
+        case 'sync': {
+            const subcommand = positionals[1];
+            if (subcommand === 'tokens') {
+                await syncTokensCommand({ output: values.output });
+            }
+            else {
+                console.error(`Unknown sync subcommand: ${subcommand}`);
+                console.log('Available: sync tokens');
+                process.exit(1);
+            }
+            break;
+        }
+        // promptui mcp [agent] [input]
+        case 'mcp': {
+            const agentKey = positionals[1];
+            const input = positionals[2];
+            if (!agentKey) {
+                listAgents();
+            }
+            else {
+                await mcpCommand(agentKey, input, {
+                    output: values.output,
+                    preview: values.preview,
+                });
+            }
+            break;
+        }
+        // promptui studio
+        case 'studio':
+            await studioCommand();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.log(HELP_TEXT);
+            process.exit(1);
+    }
+}
+// Execute CLI when run directly
+run().catch((error) => {
+    console.error('[PromptUI] Fatal error:', error.message);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@promptui-lib/cli",
+  "version": "0.1.0",
+  "private": false,
+  "description": "CLI for PromptUI - Figma to React code generator",
+  "license": "UNLICENSED",
+  "author": {
+    "name": "Desiree Menezes",
+    "url": "https://github.com/desireemenezes"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/desireemenezes/promptUI.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/desireemenezes/promptUI#readme",
+  "keywords": [
+    "figma",
+    "react",
+    "codegen",
+    "design-to-code",
+    "component-generator",
+    "scss",
+    "mui",
+    "tailwind",
+    "bootstrap"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "promptui": "./bin/promptui.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "dependencies": {
+    "@promptui-lib/core": "0.1.0",
+    "@promptui-lib/figma-parser": "0.1.0",
+    "@promptui-lib/codegen": "0.1.0",
+    "@promptui-lib/mcp-agent": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0",
+    "rimraf": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rimraf dist"
+  }
+}