expxagents 0.25.4 → 0.26.1

package/dist/cli/src/__tests__/cli.test.d.ts

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

package/dist/cli/src/__tests__/cli.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+describe('CLI', () => {
+    const cliPath = path.resolve(__dirname, '../../bin/expxagents.js');
+    it('shows help output with all commands', () => {
+        execSync('npm run build', { cwd: path.resolve(__dirname, '../..') });
+        const output = execSync(`node ${cliPath} --help`, { encoding: 'utf-8' });
+        expect(output).toContain('expxagents');
+        expect(output).toContain('init');
+        expect(output).toContain('create');
+        expect(output).toContain('run');
+        expect(output).toContain('stop');
+        expect(output).toContain('list');
+        expect(output).toContain('install');
+        expect(output).toContain('uninstall');
+        expect(output).toContain('server');
+    });
+    it('shows version', () => {
+        const output = execSync(`node ${cliPath} --version`, { encoding: 'utf-8' });
+        expect(output.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+});

package/dist/cli/src/commands/__tests__/outdated.test.d.ts

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

package/dist/cli/src/commands/__tests__/outdated.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, mkdtempSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { scanInstalledSquads } from '../outdated.js';
+describe('scanInstalledSquads', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), 'squads-test-'));
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('returns empty array when directory does not exist', () => {
+        const result = scanInstalledSquads('/nonexistent/path');
+        expect(result).toEqual([]);
+    });
+    it('returns empty array when no @scope directories exist', () => {
+        mkdirSync(join(tempDir, 'local-squad'), { recursive: true });
+        writeFileSync(join(tempDir, 'local-squad', 'squad.yaml'), 'squad:\n  version: "1.0.0"');
+        const result = scanInstalledSquads(tempDir);
+        expect(result).toEqual([]);
+    });
+    it('finds squads under @scope directories', () => {
+        const squadDir = join(tempDir, '@thulio', 'brand-squad');
+        mkdirSync(squadDir, { recursive: true });
+        writeFileSync(join(squadDir, 'squad.yaml'), 'squad:\n  code: brand-squad\n  version: "1.2.0"');
+        const result = scanInstalledSquads(tempDir);
+        expect(result).toEqual([
+            { fullName: '@thulio/brand-squad', currentVersion: '1.2.0' },
+        ]);
+    });
+    it('skips squads without squad.yaml', () => {
+        const squadDir = join(tempDir, '@thulio', 'no-yaml');
+        mkdirSync(squadDir, { recursive: true });
+        const result = scanInstalledSquads(tempDir);
+        expect(result).toEqual([]);
+    });
+    it('skips squads with invalid yaml', () => {
+        const squadDir = join(tempDir, '@thulio', 'bad-yaml');
+        mkdirSync(squadDir, { recursive: true });
+        writeFileSync(join(squadDir, 'squad.yaml'), '}{invalid');
+        const result = scanInstalledSquads(tempDir);
+        expect(result).toEqual([]);
+    });
+    it('skips squads without version field', () => {
+        const squadDir = join(tempDir, '@thulio', 'no-version');
+        mkdirSync(squadDir, { recursive: true });
+        writeFileSync(join(squadDir, 'squad.yaml'), 'squad:\n  code: no-version');
+        const result = scanInstalledSquads(tempDir);
+        expect(result).toEqual([]);
+    });
+    it('finds squads with nested tarball structure (@scope/name/name/squad.yaml)', () => {
+        const nestedDir = join(tempDir, '@community', 'copy-squad', 'copy-squad');
+        mkdirSync(nestedDir, { recursive: true });
+        writeFileSync(join(nestedDir, 'squad.yaml'), 'squad:\n  code: copy-squad\n  version: "2.0.0"');
+        const result = scanInstalledSquads(tempDir);
+        expect(result).toEqual([
+            { fullName: '@community/copy-squad', currentVersion: '2.0.0' },
+        ]);
+    });
+    it('finds multiple squads across scopes', () => {
+        const squad1 = join(tempDir, '@thulio', 'squad-a');
+        const squad2 = join(tempDir, '@community', 'squad-b');
+        mkdirSync(squad1, { recursive: true });
+        mkdirSync(squad2, { recursive: true });
+        writeFileSync(join(squad1, 'squad.yaml'), 'squad:\n  version: "1.0.0"');
+        writeFileSync(join(squad2, 'squad.yaml'), 'squad:\n  version: "2.0.0"');
+        const result = scanInstalledSquads(tempDir);
+        expect(result).toHaveLength(2);
+        expect(result).toEqual(expect.arrayContaining([
+            { fullName: '@thulio/squad-a', currentVersion: '1.0.0' },
+            { fullName: '@community/squad-b', currentVersion: '2.0.0' },
+        ]));
+    });
+});

package/dist/cli/src/mcp/__tests__/catalog.test.d.ts

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

package/dist/cli/src/mcp/__tests__/catalog.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { loadMcpCatalog, loadMcpDefinition, listAllMcpIds } from '../catalog.js';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-catalog-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+function writeCatalog(content) {
+    fs.writeFileSync(path.join(tmpDir, '_catalog.yaml'), content, 'utf-8');
+}
+function writeDefinition(id, content) {
+    fs.writeFileSync(path.join(tmpDir, `${id}.mcp.yaml`), content, 'utf-8');
+}
+describe('loadMcpCatalog', () => {
+    it('loads and parses _catalog.yaml', () => {
+        writeCatalog(`
+catalog:
+  version: "1.0.0"
+  categories:
+    - name: development
+      mcps: [github]
+    - name: communication
+      mcps: [slack]
+`);
+        const catalog = loadMcpCatalog(tmpDir);
+        expect(catalog.version).toBe('1.0.0');
+        expect(catalog.categories).toHaveLength(2);
+        expect(catalog.categories[0].name).toBe('development');
+        expect(catalog.categories[0].mcps).toEqual(['github']);
+    });
+    it('returns empty categories when catalog is missing', () => {
+        const catalog = loadMcpCatalog(tmpDir);
+        expect(catalog.categories).toEqual([]);
+    });
+});
+describe('listAllMcpIds', () => {
+    it('flattens all MCP IDs from categories', () => {
+        writeCatalog(`
+catalog:
+  version: "1.0.0"
+  categories:
+    - name: dev
+      mcps: [github, postgresql]
+    - name: comm
+      mcps: [slack]
+`);
+        const ids = listAllMcpIds(tmpDir);
+        expect(ids).toEqual(['github', 'postgresql', 'slack']);
+    });
+});
+describe('loadMcpDefinition', () => {
+    it('loads individual MCP definition by ID', () => {
+        writeDefinition('github', `
+id: github
+name: GitHub
+description: PRs and issues
+category: development
+detection:
+  method: npm
+  npm:
+    package: "@modelcontextprotocol/server-github"
+server:
+  command: npx
+  args: ["-y", "@modelcontextprotocol/server-github"]
+  env:
+    GITHUB_PERSONAL_ACCESS_TOKEN: "\${GITHUB_PERSONAL_ACCESS_TOKEN}"
+auth:
+  - key: GITHUB_PERSONAL_ACCESS_TOKEN
+    label: "GitHub Token"
+    hint: "Create at github.com/settings/tokens"
+    required: true
+tools:
+  - name: list_issues
+    description: List issues
+relevant_sectors:
+  - development
+`);
+        const def = loadMcpDefinition(tmpDir, 'github');
+        expect(def).not.toBeNull();
+        expect(def.id).toBe('github');
+        expect(def.name).toBe('GitHub');
+        expect(def.detection.method).toBe('npm');
+        expect(def.auth).toHaveLength(1);
+        expect(def.auth[0].key).toBe('GITHUB_PERSONAL_ACCESS_TOKEN');
+        expect(def.server.args).toContain('-y');
+    });
+    it('returns null for unknown MCP ID', () => {
+        const def = loadMcpDefinition(tmpDir, 'nonexistent');
+        expect(def).toBeNull();
+    });
+    it('handles malformed YAML gracefully', () => {
+        writeDefinition('broken', '{{{{not yaml');
+        const def = loadMcpDefinition(tmpDir, 'broken');
+        expect(def).toBeNull();
+    });
+});

package/dist/cli/src/mcp/__tests__/detect.test.d.ts

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

package/dist/cli/src/mcp/__tests__/detect.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { detectMcp, resolvePlatformBinary, detectExtension } from '../detect.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+function makeDef(overrides) {
+    return {
+        name: overrides.id,
+        description: '',
+        category: 'test',
+        server: { command: 'npx', args: [], env: {} },
+        auth: [],
+        tools: [],
+        relevant_sectors: [],
+        ...overrides,
+    };
+}
+describe('resolvePlatformBinary', () => {
+    it('resolves darwin + arm64', () => {
+        expect(resolvePlatformBinary('darwin', 'arm64')).toBe('mcp-server-darwin-arm64');
+    });
+    it('resolves darwin + x64', () => {
+        expect(resolvePlatformBinary('darwin', 'x64')).toBe('mcp-server-darwin-x64');
+    });
+    it('resolves linux + x64', () => {
+        expect(resolvePlatformBinary('linux', 'x64')).toBe('mcp-server-linux-x64');
+    });
+    it('resolves win32 + x64 with .exe', () => {
+        expect(resolvePlatformBinary('win32', 'x64')).toBe('mcp-server-win32-x64.exe');
+    });
+});
+describe('detectExtension', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ext-detect-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns null when no extension found', () => {
+        const result = detectExtension('nonexistent-prefix-', tmpDir);
+        expect(result).toBeNull();
+    });
+    it('finds latest version', () => {
+        fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.30'));
+        fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.35'));
+        const result = detectExtension('highagency.pencildev-', tmpDir);
+        expect(result).not.toBeNull();
+        expect(result.version).toBe('0.6.35');
+        expect(result.extensionPath).toContain('0.6.35');
+    });
+});
+describe('detectMcp', () => {
+    it('npm detection — always returns available', () => {
+        const def = makeDef({
+            id: 'slack',
+            detection: { method: 'npm', npm: { package: '@modelcontextprotocol/server-slack' } },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('available');
+        expect(result.detail).toContain('npm');
+    });
+    it('cli detection — returns unavailable when command not found', () => {
+        const def = makeDef({
+            id: 'test-cli',
+            detection: { method: 'cli', cli: { command: 'nonexistent-binary-xyz', version_flag: '--version' } },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('unavailable');
+    });
+    it('hybrid detection — falls back to npm when CLI not found', () => {
+        const def = makeDef({
+            id: 'test-hybrid',
+            detection: {
+                method: 'hybrid',
+                cli: { command: 'nonexistent-binary-xyz', version_flag: '--version' },
+                npm: { package: 'some-package' },
+            },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('available');
+        expect(result.detail).toContain('npm');
+    });
+});

package/dist/cli/src/mcp/__tests__/setup.test.d.ts

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

package/dist/cli/src/mcp/__tests__/setup.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { writeMcpConfig, removeMcpConfig, readMcpJson } from '../setup.js';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-setup-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+function makeDef(id) {
+    return {
+        id,
+        name: id,
+        description: '',
+        category: 'test',
+        detection: { method: 'npm', npm: { package: `@test/${id}` } },
+        server: { command: 'npx', args: ['-y', `@test/${id}`], env: { TOKEN: '${TOKEN}' } },
+        auth: [{ key: 'TOKEN', label: 'Token', hint: 'hint', required: true }],
+        tools: [],
+        relevant_sectors: [],
+    };
+}
+describe('writeMcpConfig', () => {
+    it('creates .mcp.json with server entry', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'abc123' });
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.github).toBeDefined();
+        expect(json.mcpServers.github.command).toBe('npx');
+        expect(json.mcpServers.github.args).toContain('-y');
+    });
+    it('merges into existing .mcp.json without overwriting', () => {
+        const existing = { mcpServers: { pencil: { command: '/bin/pencil', args: [], env: {} } } };
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify(existing, null, 2));
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'abc' });
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.pencil).toBeDefined();
+        expect(json.mcpServers.github).toBeDefined();
+    });
+    it('adds env vars to .env file', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'mytoken' });
+        const env = fs.readFileSync(path.join(tmpDir, '.env'), 'utf-8');
+        expect(env).toContain('TOKEN=mytoken');
+    });
+    it('adds placeholders to .env.example', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'mytoken' });
+        const example = fs.readFileSync(path.join(tmpDir, '.env.example'), 'utf-8');
+        expect(example).toContain('TOKEN=');
+        expect(example).not.toContain('mytoken');
+    });
+    it('handles extension-based MCP with resolved command', () => {
+        const def = makeDef('pencil');
+        def.server.command = null;
+        writeMcpConfig(tmpDir, def, {}, '/resolved/path/to/binary');
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.pencil.command).toBe('/resolved/path/to/binary');
+    });
+});
+describe('removeMcpConfig', () => {
+    it('removes MCP entry from .mcp.json', () => {
+        const existing = {
+            mcpServers: {
+                github: { command: 'npx', args: [], env: {} },
+                slack: { command: 'npx', args: [], env: {} },
+            },
+        };
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify(existing, null, 2));
+        removeMcpConfig(tmpDir, 'github');
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.github).toBeUndefined();
+        expect(json.mcpServers.slack).toBeDefined();
+    });
+});

package/dist/cli/src/mcp/__tests__/validate.test.d.ts

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

package/dist/cli/src/mcp/__tests__/validate.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { validateSquadMcps, getConfiguredMcpIds } from '../validate.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-validate-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+describe('getConfiguredMcpIds', () => {
+    it('returns MCP IDs from .mcp.json', () => {
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify({
+            mcpServers: { github: { command: 'x', args: [], env: {} }, slack: { command: 'x', args: [], env: {} } },
+        }));
+        expect(getConfiguredMcpIds(tmpDir)).toEqual(['github', 'slack']);
+    });
+    it('returns empty array when .mcp.json missing', () => {
+        expect(getConfiguredMcpIds(tmpDir)).toEqual([]);
+    });
+});
+describe('validateSquadMcps', () => {
+    it('passes when squad has no mcps field', () => {
+        expect(() => validateSquadMcps(undefined, ['github'])).not.toThrow();
+    });
+    it('passes when squad has empty mcps', () => {
+        expect(() => validateSquadMcps([], ['github'])).not.toThrow();
+    });
+    it('passes when all required MCPs are configured', () => {
+        expect(() => validateSquadMcps(['github', 'slack'], ['github', 'slack', 'sentry'])).not.toThrow();
+    });
+    it('throws when required MCP is not configured', () => {
+        expect(() => validateSquadMcps(['github', 'linear'], ['github']))
+            .toThrow(/linear/i);
+    });
+    it('includes setup command in error message', () => {
+        expect(() => validateSquadMcps(['linear'], []))
+            .toThrow(/expxagents mcp setup/i);
+    });
+});

package/dist/cli/src/pencil/__tests__/detect.test.d.ts

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

package/dist/cli/src/pencil/__tests__/detect.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { detectPencilExtension, resolvePlatformBinary, buildMcpConfig, } from '../detect.js';
+describe('pencil/detect', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pencil-detect-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    describe('detectPencilExtension()', () => {
+        it('returns null when no extension directories exist', () => {
+            const result = detectPencilExtension(tmpDir);
+            expect(result).toBeNull();
+        });
+        it('returns the latest version when multiple versions exist', () => {
+            fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.33', 'out'), { recursive: true });
+            fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.35', 'out'), { recursive: true });
+            fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.34', 'out'), { recursive: true });
+            const result = detectPencilExtension(tmpDir);
+            expect(result).not.toBeNull();
+            expect(result.version).toBe('0.6.35');
+            expect(result.extensionPath).toContain('highagency.pencildev-0.6.35');
+        });
+        it('returns info for a single installed version', () => {
+            fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.33', 'out'), { recursive: true });
+            const result = detectPencilExtension(tmpDir);
+            expect(result).not.toBeNull();
+            expect(result.version).toBe('0.6.33');
+        });
+    });
+    describe('resolvePlatformBinary()', () => {
+        it('returns darwin-arm64 for macOS ARM', () => {
+            const binary = resolvePlatformBinary('darwin', 'arm64');
+            expect(binary).toBe('mcp-server-darwin-arm64');
+        });
+        it('returns darwin-x64 for macOS Intel', () => {
+            const binary = resolvePlatformBinary('darwin', 'x64');
+            expect(binary).toBe('mcp-server-darwin-x64');
+        });
+        it('returns linux-x64 for Linux', () => {
+            const binary = resolvePlatformBinary('linux', 'x64');
+            expect(binary).toBe('mcp-server-linux-x64');
+        });
+        it('returns win32-x64.exe for Windows', () => {
+            const binary = resolvePlatformBinary('win32', 'x64');
+            expect(binary).toBe('mcp-server-win32-x64.exe');
+        });
+    });
+    describe('buildMcpConfig()', () => {
+        it('generates correct config object', () => {
+            const info = {
+                version: '0.6.35',
+                extensionPath: '/Users/test/.vscode/extensions/highagency.pencildev-0.6.35',
+            };
+            const config = buildMcpConfig(info, 'mcp-server-darwin-arm64');
+            expect(config).toEqual({
+                mcpServers: {
+                    pencil: {
+                        command: '/Users/test/.vscode/extensions/highagency.pencildev-0.6.35/out/mcp-server-darwin-arm64',
+                        args: ['--app', 'visual_studio_code'],
+                        env: {},
+                    },
+                },
+            });
+        });
+    });
+});

package/dist/cli/src/pencil/__tests__/property-mapper.test.d.ts

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

package/dist/cli/src/pencil/__tests__/property-mapper.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+import { mapNodeToCSS } from '../property-mapper.js';
+describe('pencil/property-mapper', () => {
+    it('maps fill to background-color for frame nodes', () => {
+        const node = { type: 'frame', fill: '#FF5733' };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('background: #FF5733');
+    });
+    it('maps fill to color for text nodes', () => {
+        const node = { type: 'text', fill: '#333333' };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('color: #333333');
+    });
+    it('maps font properties', () => {
+        const node = {
+            type: 'text',
+            fontSize: 24,
+            fontWeight: '700',
+            fontFamily: 'Inter',
+            lineHeight: 1.5,
+            letterSpacing: 0.5,
+        };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('font-size: 24px');
+        expect(css).toContain('font-weight: 700');
+        expect(css).toContain('font-family: Inter');
+        expect(css).toContain('line-height: 1.5');
+        expect(css).toContain('letter-spacing: 0.5px');
+    });
+    it('maps padding array [T,R,B,L]', () => {
+        const node = { type: 'frame', padding: [10, 20, 10, 20] };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('padding: 10px 20px 10px 20px');
+    });
+    it('maps padding array [V,H]', () => {
+        const node = { type: 'frame', padding: [10, 20] };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('padding: 10px 20px');
+    });
+    it('maps single padding value', () => {
+        const node = { type: 'frame', padding: 16 };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('padding: 16px');
+    });
+    it('maps layout vertical to flex-direction column', () => {
+        const node = { type: 'frame', layout: 'vertical' };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('display: flex');
+        expect(css).toContain('flex-direction: column');
+    });
+    it('maps layout horizontal to flex-direction row', () => {
+        const node = { type: 'frame', layout: 'horizontal' };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('display: flex');
+        expect(css).toContain('flex-direction: row');
+    });
+    it('maps gap', () => {
+        const node = { type: 'frame', gap: 12 };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('gap: 12px');
+    });
+    it('maps width fill_container to width 100%', () => {
+        const node = { type: 'frame', width: 'fill_container' };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('width: 100%');
+    });
+    it('maps width fit_content', () => {
+        const node = { type: 'frame', width: 'fit_content' };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('width: fit-content');
+    });
+    it('maps numeric width to px', () => {
+        const node = { type: 'frame', width: 300 };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('width: 300px');
+    });
+    it('maps cornerRadius to border-radius', () => {
+        const node = { type: 'frame', cornerRadius: 8 };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('border-radius: 8px');
+    });
+    it('maps cornerRadius array', () => {
+        const node = { type: 'frame', cornerRadius: [8, 8, 0, 0] };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('border-radius: 8px 8px 0px 0px');
+    });
+    it('maps clip true to overflow hidden', () => {
+        const node = { type: 'frame', clip: true };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('overflow: hidden');
+    });
+    it('maps opacity', () => {
+        const node = { type: 'frame', opacity: 0.5 };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('opacity: 0.5');
+    });
+    it('maps justifyContent and alignItems', () => {
+        const node = {
+            type: 'frame',
+            justifyContent: 'center',
+            alignItems: 'flex-start',
+        };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('justify-content: center');
+        expect(css).toContain('align-items: flex-start');
+    });
+    it('maps stroke to border', () => {
+        const node = {
+            type: 'frame',
+            stroke: { thickness: 2, fill: '#000000' },
+        };
+        const css = mapNodeToCSS(node);
+        expect(css).toContain('border: 2px solid #000000');
+    });
+    it('returns empty string for empty node', () => {
+        const node = { type: 'frame' };
+        const css = mapNodeToCSS(node);
+        expect(css).toBe('');
+    });
+});

package/dist/cli/src/pencil/__tests__/template-sync.test.d.ts

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