expxagents 0.18.2 → 0.20.0

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

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+export function loadMcpCatalog(mcpsDir) {
+    const catalogPath = path.join(mcpsDir, '_catalog.yaml');
+    if (!fs.existsSync(catalogPath)) {
+        return { version: '0.0.0', categories: [] };
+    }
+    try {
+        const raw = fs.readFileSync(catalogPath, 'utf-8');
+        const parsed = yaml.load(raw);
+        const catalog = parsed?.catalog;
+        return {
+            version: catalog?.version ?? '0.0.0',
+            categories: catalog?.categories ?? [],
+        };
+    }
+    catch {
+        return { version: '0.0.0', categories: [] };
+    }
+}
+export function listAllMcpIds(mcpsDir) {
+    const catalog = loadMcpCatalog(mcpsDir);
+    return catalog.categories.flatMap(c => c.mcps);
+}
+export function loadMcpDefinition(mcpsDir, id) {
+    const defPath = path.join(mcpsDir, `${id}.mcp.yaml`);
+    if (!fs.existsSync(defPath)) {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(defPath, 'utf-8');
+        const parsed = yaml.load(raw);
+        if (!parsed?.id || !parsed?.detection) {
+            return null;
+        }
+        return {
+            id: parsed.id,
+            name: parsed.name ?? parsed.id,
+            description: parsed.description ?? '',
+            category: parsed.category ?? 'other',
+            icon: parsed.icon,
+            detection: parsed.detection,
+            server: parsed.server ?? { command: null, args: [], env: {} },
+            auth: parsed.auth ?? [],
+            tools: parsed.tools ?? [],
+            relevant_sectors: parsed.relevant_sectors ?? [],
+        };
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { McpDefinition, McpDetectionResult } from './types.js';
+export declare function resolvePlatformBinary(platform?: string, arch?: string): string;
+export interface ExtensionInfo {
+    version: string;
+    extensionPath: string;
+}
+export declare function detectExtension(prefix: string, extensionsDir?: string): ExtensionInfo | null;
+export declare function detectMcp(def: McpDefinition, extensionsDir?: string): McpDetectionResult;
+export declare function detectAllMcps(definitions: McpDefinition[], extensionsDir?: string): McpDetectionResult[];

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

@@ -0,0 +1,75 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+export function resolvePlatformBinary(platform, arch) {
+    const p = platform ?? process.platform;
+    const a = arch ?? process.arch;
+    if (p === 'win32')
+        return 'mcp-server-win32-x64.exe';
+    return `mcp-server-${p}-${a}`;
+}
+export function detectExtension(prefix, extensionsDir) {
+    const dir = extensionsDir ?? path.join(os.homedir(), '.vscode', 'extensions');
+    if (!fs.existsSync(dir))
+        return null;
+    const entries = fs.readdirSync(dir)
+        .filter(e => e.startsWith(prefix))
+        .sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }));
+    if (entries.length === 0)
+        return null;
+    const latest = entries[entries.length - 1];
+    return {
+        version: latest.slice(prefix.length),
+        extensionPath: path.join(dir, latest),
+    };
+}
+function detectCli(command, versionFlag) {
+    try {
+        const output = execSync(`${command} ${versionFlag}`, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const match = output.match(/(\d+\.\d+[\.\d]*)/);
+        return { found: true, version: match?.[1] ?? 'unknown' };
+    }
+    catch {
+        return { found: false };
+    }
+}
+export function detectMcp(def, extensionsDir) {
+    const base = { id: def.id, name: def.name };
+    const { method } = def.detection;
+    if (method === 'cli' && def.detection.cli) {
+        const { command, version_flag } = def.detection.cli;
+        const cli = detectCli(command, version_flag);
+        if (cli.found) {
+            return { ...base, status: 'detected', detail: `${command} v${cli.version} found`, version: cli.version };
+        }
+        return { ...base, status: 'unavailable', detail: `${command} not found in PATH` };
+    }
+    if (method === 'npm' && def.detection.npm) {
+        return { ...base, status: 'available', detail: `Available via npm (${def.detection.npm.package})` };
+    }
+    if (method === 'extension' && def.detection.extension) {
+        const ext = detectExtension(def.detection.extension.prefix, extensionsDir);
+        if (ext) {
+            return { ...base, status: 'detected', detail: `VSCode extension v${ext.version}`, version: ext.version, extensionPath: ext.extensionPath };
+        }
+        return { ...base, status: 'unavailable', detail: 'VSCode extension not found' };
+    }
+    if (method === 'hybrid') {
+        if (def.detection.cli) {
+            const { command, version_flag } = def.detection.cli;
+            const cli = detectCli(command, version_flag);
+            if (cli.found) {
+                return { ...base, status: 'detected', detail: `${command} v${cli.version} found`, version: cli.version };
+            }
+        }
+        if (def.detection.npm) {
+            return { ...base, status: 'available', detail: `Available via npm (${def.detection.npm.package})` };
+        }
+        return { ...base, status: 'unavailable', detail: 'No CLI or npm package available' };
+    }
+    return { ...base, status: 'unavailable', detail: 'Unknown detection method' };
+}
+export function detectAllMcps(definitions, extensionsDir) {
+    return definitions.map(def => detectMcp(def, extensionsDir));
+}

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

@@ -0,0 +1,4 @@
+import type { McpDefinition, McpJson } from './types.js';
+export declare function readMcpJson(projectDir: string): McpJson;
+export declare function writeMcpConfig(projectDir: string, def: McpDefinition, authValues: Record<string, string>, resolvedCommand?: string): void;
+export declare function removeMcpConfig(projectDir: string, mcpId: string): void;

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

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+export function readMcpJson(projectDir) {
+    const mcpPath = path.join(projectDir, '.mcp.json');
+    if (!fs.existsSync(mcpPath)) {
+        return { mcpServers: {} };
+    }
+    try {
+        return JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+    }
+    catch {
+        return { mcpServers: {} };
+    }
+}
+export function writeMcpConfig(projectDir, def, authValues, resolvedCommand) {
+    const mcpJson = readMcpJson(projectDir);
+    const command = resolvedCommand ?? def.server.command;
+    if (!command)
+        return;
+    mcpJson.mcpServers[def.id] = {
+        command,
+        args: def.server.args,
+        env: { ...def.server.env },
+    };
+    fs.writeFileSync(path.join(projectDir, '.mcp.json'), JSON.stringify(mcpJson, null, 2) + '\n');
+    // Write env vars
+    const envPath = path.join(projectDir, '.env');
+    const examplePath = path.join(projectDir, '.env.example');
+    let envContent = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf-8') : '';
+    let exampleContent = fs.existsSync(examplePath) ? fs.readFileSync(examplePath, 'utf-8') : '';
+    const mcpHeader = `\n# MCP: ${def.name}\n`;
+    let envBlock = '';
+    let exampleBlock = '';
+    for (const auth of def.auth) {
+        const value = authValues[auth.key] ?? '';
+        if (!envContent.includes(`${auth.key}=`)) {
+            envBlock += `${auth.key}=${value}\n`;
+        }
+        if (!exampleContent.includes(`${auth.key}=`)) {
+            exampleBlock += `${auth.key}=\n`;
+        }
+    }
+    if (envBlock) {
+        envContent += mcpHeader + envBlock;
+        fs.writeFileSync(envPath, envContent);
+    }
+    if (exampleBlock) {
+        exampleContent += mcpHeader + exampleBlock;
+        fs.writeFileSync(examplePath, exampleContent);
+    }
+}
+export function removeMcpConfig(projectDir, mcpId) {
+    const mcpJson = readMcpJson(projectDir);
+    delete mcpJson.mcpServers[mcpId];
+    fs.writeFileSync(path.join(projectDir, '.mcp.json'), JSON.stringify(mcpJson, null, 2) + '\n');
+}

package/dist/cli/src/mcp/types.d.ts

@@ -0,0 +1,68 @@
+export interface McpAuthEntry {
+    key: string;
+    label: string;
+    hint: string;
+    required: boolean;
+    validate?: string;
+}
+export interface McpToolEntry {
+    name: string;
+    description: string;
+}
+export interface McpDetectionConfig {
+    method: 'cli' | 'npm' | 'extension' | 'hybrid';
+    cli?: {
+        command: string;
+        version_flag: string;
+        min_version?: string;
+    };
+    npm?: {
+        package: string;
+    };
+    extension?: {
+        prefix: string;
+        binary_dir: string;
+        binary_resolve: 'platform';
+    };
+}
+export interface McpServerConfig {
+    command: string | null;
+    args: string[];
+    env: Record<string, string>;
+}
+export interface McpDefinition {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    icon?: string;
+    detection: McpDetectionConfig;
+    server: McpServerConfig;
+    auth: McpAuthEntry[];
+    tools: McpToolEntry[];
+    relevant_sectors: string[];
+}
+export interface McpCatalogCategory {
+    name: string;
+    mcps: string[];
+}
+export interface McpCatalog {
+    version: string;
+    categories: McpCatalogCategory[];
+}
+export interface McpDetectionResult {
+    id: string;
+    name: string;
+    status: 'detected' | 'available' | 'unavailable';
+    detail: string;
+    version?: string;
+    extensionPath?: string;
+}
+export interface McpJsonEntry {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+export interface McpJson {
+    mcpServers: Record<string, McpJsonEntry>;
+}

package/dist/cli/src/mcp/types.js

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

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

@@ -0,0 +1,2 @@
+export declare function getConfiguredMcpIds(projectDir: string): string[];
+export declare function validateSquadMcps(squadMcps: string[] | undefined, configuredMcps: string[]): void;

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

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+export function getConfiguredMcpIds(projectDir) {
+    const mcpPath = path.join(projectDir, '.mcp.json');
+    if (!fs.existsSync(mcpPath))
+        return [];
+    try {
+        const json = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+        return Object.keys(json.mcpServers ?? {});
+    }
+    catch {
+        return [];
+    }
+}
+export function validateSquadMcps(squadMcps, configuredMcps) {
+    if (!squadMcps || squadMcps.length === 0)
+        return;
+    const missing = squadMcps.filter(m => !configuredMcps.includes(m));
+    if (missing.length > 0) {
+        throw new Error(`Squad requires MCPs not configured: ${missing.join(', ')}.\n` +
+            `Run: expxagents mcp setup ${missing.join(' ')}`);
+    }
+}

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 {};

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

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import { parseFrameName, generateTemplateMarkdown, computeSyncActions, } from '../template-sync.js';
+describe('pencil/template-sync', () => {
+    describe('parseFrameName()', () => {
+        it('parses "Template 01 - Hero Banner"', () => {
+            const result = parseFrameName('Template 01 - Hero Banner');
+            expect(result).toEqual({ number: 1, name: 'Hero Banner', slug: 'hero-banner' });
+        });
+        it('parses "Template 12 - Call to Action"', () => {
+            const result = parseFrameName('Template 12 - Call to Action');
+            expect(result).toEqual({ number: 12, name: 'Call to Action', slug: 'call-to-action' });
+        });
+        it('returns null for non-template frame names', () => {
+            expect(parseFrameName('Random Frame')).toBeNull();
+            expect(parseFrameName('Background')).toBeNull();
+        });
+    });
+    describe('generateTemplateMarkdown()', () => {
+        it('generates markdown with CSS from node properties', () => {
+            const frame = {
+                id: 'frame1',
+                name: 'Template 01 - Hero Banner',
+                width: 1080,
+                height: 1350,
+                children: [
+                    {
+                        id: 'child1',
+                        name: 'Header',
+                        type: 'frame',
+                        fill: '#FFFFFF',
+                        layout: 'vertical',
+                        padding: [20, 24, 20, 24],
+                    },
+                ],
+            };
+            const md = generateTemplateMarkdown(frame);
+            expect(md).toContain('# Template 01 — Hero Banner');
+            expect(md).toContain('1080x1350');
+            expect(md).toContain('background: #FFFFFF');
+            expect(md).toContain('flex-direction: column');
+        });
+    });
+    describe('computeSyncActions()', () => {
+        it('detects new templates (frame without .md)', () => {
+            const frames = [
+                { id: 'f1', name: 'Template 01 - Hero', width: 1080, height: 1350, children: [] },
+            ];
+            const existingMds = [];
+            const actions = computeSyncActions(frames, existingMds);
+            expect(actions).toHaveLength(1);
+            expect(actions[0].type).toBe('create');
+            expect(actions[0].filename).toBe('template-01-hero.md');
+        });
+        it('detects orphaned templates (.md without frame)', () => {
+            const frames = [];
+            const existingMds = ['template-01-hero.md'];
+            const actions = computeSyncActions(frames, existingMds);
+            expect(actions).toHaveLength(1);
+            expect(actions[0].type).toBe('orphan');
+            expect(actions[0].filename).toBe('template-01-hero.md');
+        });
+        it('detects existing templates that may need update', () => {
+            const frames = [
+                { id: 'f1', name: 'Template 01 - Hero', width: 1080, height: 1350, children: [] },
+            ];
+            const existingMds = ['template-01-hero.md'];
+            const actions = computeSyncActions(frames, existingMds);
+            expect(actions).toHaveLength(1);
+            expect(actions[0].type).toBe('update');
+        });
+        it('handles mix of new, existing, and orphaned', () => {
+            const frames = [
+                { id: 'f1', name: 'Template 01 - Hero', width: 1080, height: 1350, children: [] },
+                { id: 'f2', name: 'Template 03 - Footer', width: 1080, height: 1350, children: [] },
+            ];
+            const existingMds = ['template-01-hero.md', 'template-02-sidebar.md'];
+            const actions = computeSyncActions(frames, existingMds);
+            const create = actions.filter(a => a.type === 'create');
+            const update = actions.filter(a => a.type === 'update');
+            const orphan = actions.filter(a => a.type === 'orphan');
+            expect(update).toHaveLength(1); // template-01 exists
+            expect(create).toHaveLength(1); // template-03 is new
+            expect(orphan).toHaveLength(1); // template-02 has no frame
+        });
+        it('skips non-template frames', () => {
+            const frames = [
+                { id: 'f1', name: 'Background', width: 1920, height: 1080, children: [] },
+                { id: 'f2', name: 'Template 01 - Hero', width: 1080, height: 1350, children: [] },
+            ];
+            const actions = computeSyncActions(frames, []);
+            expect(actions).toHaveLength(1);
+            expect(actions[0].filename).toBe('template-01-hero.md');
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+/**
+ * @deprecated — Use cli/src/mcp/detect.ts instead. This file re-exports for backwards compatibility.
+ */
+export { resolvePlatformBinary } from '../mcp/detect.js';
+export interface PencilInfo {
+    version: string;
+    extensionPath: string;
+}
+export interface McpConfig {
+    mcpServers: {
+        pencil: {
+            command: string;
+            args: string[];
+            env: Record<string, string>;
+        };
+    };
+}
+/** @deprecated Use detectExtension from cli/src/mcp/detect.ts */
+export declare function detectPencilExtension(extensionsDir?: string): PencilInfo | null;
+/** @deprecated Use writeMcpConfig from cli/src/mcp/setup.ts */
+export declare function buildMcpConfig(info: PencilInfo, binaryName: string): McpConfig;

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

@@ -0,0 +1,23 @@
+/**
+ * @deprecated — Use cli/src/mcp/detect.ts instead. This file re-exports for backwards compatibility.
+ */
+export { resolvePlatformBinary } from '../mcp/detect.js';
+import { detectExtension } from '../mcp/detect.js';
+import path from 'path';
+const EXTENSION_PREFIX = 'highagency.pencildev-';
+/** @deprecated Use detectExtension from cli/src/mcp/detect.ts */
+export function detectPencilExtension(extensionsDir) {
+    return detectExtension(EXTENSION_PREFIX, extensionsDir);
+}
+/** @deprecated Use writeMcpConfig from cli/src/mcp/setup.ts */
+export function buildMcpConfig(info, binaryName) {
+    return {
+        mcpServers: {
+            pencil: {
+                command: path.join(info.extensionPath, 'out', binaryName),
+                args: ['--app', 'visual_studio_code'],
+                env: {},
+            },
+        },
+    };
+}