aub-workspace 0.3.0

package/vendor/aub/apps/mcp-server/dist/aub.js

@@ -0,0 +1,15 @@
+// Single bridge to the repository's pure-function libraries in `scripts/`.
+// All relative paths to scripts/*.lib.mjs live here so emitted dist depth stays predictable.
+export { exportMarkdown } from '../../../scripts/export-md.lib.mjs';
+export { exportAgentPrompt, supportedAgentAdapters, supportedAgentTasks, } from '../../../scripts/export-agent-prompt.lib.mjs';
+export { validateBlueprintSemantics } from '../../../scripts/validate-blueprint.lib.mjs';
+export { buildKnownTypes } from '../../../scripts/registry.lib.mjs';
+export { diffBlueprints } from '../../../scripts/diff-blueprint.lib.mjs';
+export { migrateBlueprint } from '../../../scripts/migrate-blueprint.mjs';
+export { createBlueprintLock } from '../../../scripts/lock-blueprint.lib.mjs';
+export { createHandoffArchive } from '../../../scripts/handoff-package.lib.mjs';
+export { importDesignBridge, DESIGN_BRIDGE_VERSION } from '../../../scripts/design-bridge.lib.mjs';
+export { scaffoldBlueprint, SCAFFOLD_SECTIONS } from '../../../scripts/scaffold-blueprint.lib.mjs';
+export { createImplementationReportTemplate, verifyImplementationReport, } from '../../../scripts/implementation-report.lib.mjs';
+export { loadProject, validateProjectSemantics, parseProjectText, mergeDesignSystem, PROJECT_VERSION, } from '../../../scripts/project.lib.mjs';
+export { approveComponentCandidate, generateTemplateFromSource, getWorkspaceStatus, readAubSession, scanProjectUi, templateAuthoringPrompt, updateAubSession, } from '../../../scripts/workspace-loop.lib.mjs';

package/vendor/aub/apps/mcp-server/dist/context.js

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

package/vendor/aub/apps/mcp-server/dist/http.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
+import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import express from 'express';
+import { loadValidators } from './schema.js';
+import { createAubServer, registeredToolNames, runAubTool } from './server.js';
+function option(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+function resolveConfig() {
+    const positional = process.argv[2]?.startsWith('--') ? undefined : process.argv[2];
+    const root = resolve(option('--workspace') ?? positional ?? process.env.AUB_WORKSPACE ?? process.cwd());
+    const host = option('--host') ?? process.env.AUB_HOST ?? '127.0.0.1';
+    const port = Number(option('--port') ?? process.env.AUB_PORT ?? 3100);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid port: ${String(port)}`);
+    }
+    return { root, host, port };
+}
+async function main() {
+    const { root, host, port } = resolveConfig();
+    const validators = await loadValidators();
+    const ctx = { root, validators };
+    const app = createMcpExpressApp({ host });
+    const transports = new Map();
+    app.use(express.json({ limit: '20mb' }));
+    app.use((req, res, next) => {
+        const origin = req.headers.origin;
+        if (origin && /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/.test(origin)) {
+            res.setHeader('Access-Control-Allow-Origin', origin);
+        }
+        else if (origin === 'https://henrylau1103.github.io') {
+            res.setHeader('Access-Control-Allow-Origin', origin);
+        }
+        res.setHeader('Vary', 'Origin');
+        res.setHeader('Access-Control-Allow-Headers', 'content-type, mcp-session-id');
+        res.setHeader('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
+        if (req.method === 'OPTIONS') {
+            res.status(204).end();
+            return;
+        }
+        next();
+    });
+    app.get('/health', (_req, res) => {
+        res.json({
+            status: 'ok',
+            service: 'aub-mcp-server',
+            version: '0.3.0',
+            workspace: root,
+            tools: registeredToolNames(),
+        });
+    });
+    app.post('/rpc', async (req, res) => {
+        try {
+            const tool = String(req.body?.tool ?? '');
+            const args = req.body?.args ?? {};
+            const result = await runAubTool(ctx, tool, args);
+            res.json({ ok: true, result });
+        }
+        catch (error) {
+            res.status(400).json({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    app.all('/mcp', async (req, res) => {
+        try {
+            const sessionId = req.headers['mcp-session-id'];
+            let transport = typeof sessionId === 'string' ? transports.get(sessionId) : undefined;
+            if (!transport && req.method === 'POST' && isInitializeRequest(req.body)) {
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (id) => {
+                        transports.set(id, transport);
+                    },
+                });
+                transport.onclose = () => {
+                    if (transport?.sessionId)
+                        transports.delete(transport.sessionId);
+                };
+                await createAubServer(ctx).connect(transport);
+            }
+            if (!transport) {
+                res.status(400).json({
+                    jsonrpc: '2.0',
+                    error: { code: -32000, message: 'A valid MCP session is required.' },
+                    id: null,
+                });
+                return;
+            }
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            console.error('AUB MCP HTTP request failed:', error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: '2.0',
+                    error: { code: -32603, message: 'Internal server error' },
+                    id: null,
+                });
+            }
+        }
+    });
+    const listener = app.listen(port, host, () => {
+        console.error(`aub-mcp-server HTTP ready at http://${host}:${port}/mcp (workspace: ${root})`);
+    });
+    const shutdown = async () => {
+        for (const transport of transports.values())
+            await transport.close();
+        listener.close(() => process.exit(0));
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/vendor/aub/apps/mcp-server/dist/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadValidators } from './schema.js';
+import { createAubServer } from './server.js';
+export function resolveWorkspaceRoot() {
+    const fromArg = process.argv[2];
+    const fromEnv = process.env.AUB_WORKSPACE;
+    return resolve(fromArg ?? fromEnv ?? process.cwd());
+}
+async function main() {
+    const root = resolveWorkspaceRoot();
+    const validators = await loadValidators();
+    const ctx = { root, validators };
+    const server = createAubServer(ctx);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`aub-mcp-server ready (workspace: ${root})`);
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/vendor/aub/apps/mcp-server/dist/repo.js

@@ -0,0 +1,17 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// Walk up from this module to find the AUB repository root (the directory that
+// owns schema/ui-blueprint.schema.json). Works from both src/ and dist/ layouts.
+export function findRepoRoot() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 12; i += 1) {
+        if (existsSync(join(dir, 'schema', 'ui-blueprint.schema.json')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error('Could not locate AUB repo root (schema/ui-blueprint.schema.json not found).');
+}

package/vendor/aub/apps/mcp-server/dist/schema.js

@@ -0,0 +1,42 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import AjvModule from 'ajv/dist/2020.js';
+import addFormatsModule from 'ajv-formats';
+import { findRepoRoot } from './repo.js';
+// ajv and ajv-formats ship as CJS; normalize the default export across loaders.
+const Ajv2020 = (AjvModule.default ?? AjvModule);
+const addFormats = (addFormatsModule.default ?? addFormatsModule);
+let cached = null;
+export async function loadValidators() {
+    if (cached)
+        return cached;
+    const root = findRepoRoot();
+    const [blueprintRaw, reportRaw, projectRaw, designBridgeRaw] = await Promise.all([
+        readFile(join(root, 'schema', 'ui-blueprint.schema.json'), 'utf8'),
+        readFile(join(root, 'schema', 'implementation-report.schema.json'), 'utf8'),
+        readFile(join(root, 'schema', 'ui-project.schema.json'), 'utf8'),
+        readFile(join(root, 'schema', 'design-bridge.schema.json'), 'utf8'),
+    ]);
+    const blueprintSchema = JSON.parse(blueprintRaw);
+    const reportSchema = JSON.parse(reportRaw);
+    const projectSchema = JSON.parse(projectRaw);
+    const designBridgeSchema = JSON.parse(designBridgeRaw);
+    const ajv = new Ajv2020({ allErrors: true, strict: true });
+    addFormats(ajv);
+    const validateBlueprint = ajv.compile(blueprintSchema);
+    cached = {
+        validateBlueprint,
+        validateReport: ajv.compile(reportSchema),
+        validateProject: ajv.compile(projectSchema),
+        validateDesignBridge: ajv.compile(designBridgeSchema),
+        reportSchema,
+    };
+    return cached;
+}
+export function formatAjvErrors(validate) {
+    return (validate.errors ?? []).map((err) => {
+        const path = err.instancePath || '(root)';
+        const params = err.params ? ` ${JSON.stringify(err.params)}` : '';
+        return `${path} ${err.message ?? 'invalid'}${params}`.trim();
+    });
+}

package/vendor/aub/apps/mcp-server/dist/server.js

@@ -0,0 +1,80 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import * as listBlueprints from './tools/list-blueprints.js';
+import * as getBlueprint from './tools/get-blueprint.js';
+import * as validateBlueprint from './tools/validate-blueprint.js';
+import * as scaffoldBlueprint from './tools/scaffold-blueprint.js';
+import * as importDesignBridge from './tools/import-design-bridge.js';
+import * as writeBlueprint from './tools/write-blueprint.js';
+import * as exportPrompt from './tools/export-prompt.js';
+import * as exportHandoff from './tools/export-handoff.js';
+import * as submitReport from './tools/submit-report.js';
+import * as listProjects from './tools/list-projects.js';
+import * as getProject from './tools/get-project.js';
+import * as validateProject from './tools/validate-project.js';
+import * as resolveComponent from './tools/resolve-component.js';
+import * as diffBlueprints from './tools/diff-blueprints.js';
+import * as migrateBlueprint from './tools/migrate-blueprint.js';
+import * as lockBlueprint from './tools/lock-blueprint.js';
+import * as getAubSession from './tools/get-aub-session.js';
+import * as updateAubSession from './tools/update-aub-session.js';
+import * as getWorkspaceStatus from './tools/get-workspace-status.js';
+import * as scanProjectUi from './tools/scan-project-ui.js';
+import * as generateTemplateFromSource from './tools/generate-template-from-source.js';
+import * as approveComponentCandidate from './tools/approve-component-candidate.js';
+import * as exportTemplateAuthoringPrompt from './tools/export-template-authoring-prompt.js';
+const tools = [
+    listBlueprints,
+    getBlueprint,
+    validateBlueprint,
+    scaffoldBlueprint,
+    importDesignBridge,
+    writeBlueprint,
+    exportPrompt,
+    exportHandoff,
+    submitReport,
+    listProjects,
+    getProject,
+    validateProject,
+    resolveComponent,
+    diffBlueprints,
+    migrateBlueprint,
+    lockBlueprint,
+    getAubSession,
+    updateAubSession,
+    getWorkspaceStatus,
+    scanProjectUi,
+    generateTemplateFromSource,
+    approveComponentCandidate,
+    exportTemplateAuthoringPrompt,
+];
+function ok(payload) {
+    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+}
+function fail(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { content: [{ type: 'text', text: JSON.stringify({ error: message }, null, 2) }], isError: true };
+}
+export function createAubServer(ctx) {
+    const server = new McpServer({ name: 'aub-mcp-server', version: '0.3.0' });
+    for (const tool of tools) {
+        server.registerTool(tool.name, tool.config, async (args) => {
+            try {
+                return ok(await tool.run(ctx, args));
+            }
+            catch (error) {
+                return fail(error);
+            }
+        });
+    }
+    return server;
+}
+export function registeredToolNames() {
+    return tools.map((tool) => tool.name);
+}
+export async function runAubTool(ctx, name, args = {}) {
+    const tool = tools.find((candidate) => candidate.name === name);
+    if (!tool) {
+        throw new Error(`Unknown AUB tool "${name}". Available: ${registeredToolNames().join(', ')}.`);
+    }
+    return tool.run(ctx, args);
+}

package/vendor/aub/apps/mcp-server/dist/tools/approve-component-candidate.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { approveComponentCandidate } from '../aub.js';
+export const name = 'approve_component_candidate';
+const inputSchema = {
+    id: z.string().describe('Component candidate id from .aub/component-candidates.json.'),
+    action: z
+        .enum(['create_extension', 'map_core', 'ignore'])
+        .describe('Review decision. create_extension writes aub.registry.json; map_core and ignore only update the candidate record.'),
+    coreType: z.string().optional().describe('Core AUB component type when action is map_core.'),
+    namespacedType: z.string().optional().describe('Approved team:component type when action is create_extension.'),
+    isContainer: z.boolean().optional().describe('Container behavior override for create_extension.'),
+    description: z.string().optional().describe('Description override for the extension entry.'),
+    module: z.string().optional().describe('Production module/source override for the extension implementation.'),
+    export: z.string().optional().describe('Production export symbol override for the extension implementation.'),
+    importStyle: z
+        .enum(['named', 'default', 'namespace', 'side-effect', 'custom-element'])
+        .optional()
+        .describe('Production import style override for the extension implementation.'),
+};
+export const config = {
+    title: 'Approve Component Candidate',
+    description: 'Review a scanned custom component candidate. Only create_extension writes aub.registry.json; other decisions stay in .aub/component-candidates.json.',
+    inputSchema,
+};
+export async function run(ctx, args) {
+    return approveComponentCandidate(ctx.root, args ?? {});
+}

package/vendor/aub/apps/mcp-server/dist/tools/diff-blueprints.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { resolveBlueprint } from '../workspace.js';
+import { diffBlueprints } from '../aub.js';
+export const name = 'diff_blueprints';
+const inputSchema = {
+    before: z.string().describe('Baseline Blueprint file path or screen id.'),
+    after: z.string().describe('Updated Blueprint file path or screen id.'),
+};
+export const config = {
+    title: 'Diff Blueprints',
+    description: 'Compare two Blueprint revisions and return structural changes across nodes, interactions, responsive rules, acceptance, viewports, and design tokens.',
+    inputSchema,
+};
+export async function run(ctx, args) {
+    if (!args.before || !args.after) {
+        throw new Error('Provide both "before" and "after" Blueprint refs.');
+    }
+    const [before, after] = await Promise.all([
+        resolveBlueprint(ctx.root, args.before),
+        resolveBlueprint(ctx.root, args.after),
+    ]);
+    return {
+        beforePath: before.entry.path,
+        afterPath: after.entry.path,
+        diff: diffBlueprints(before.blueprint, after.blueprint),
+    };
+}

package/vendor/aub/apps/mcp-server/dist/tools/export-handoff.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, relative, resolve, sep } from 'node:path';
+import { z } from 'zod';
+import { buildKnownTypes, createHandoffArchive, createImplementationReportTemplate, exportAgentPrompt, exportMarkdown, validateBlueprintSemantics, } from '../aub.js';
+import { findRepoRoot } from '../repo.js';
+import { formatAjvErrors } from '../schema.js';
+import { resolveBlueprint, resolveWorkspacePath } from '../workspace.js';
+export const name = 'export_handoff';
+const inputSchema = {
+    ref: z.string().describe('Blueprint file path or screen id.'),
+    output: z
+        .string()
+        .optional()
+        .describe('Destination .aub.zip path inside the workspace. Defaults to .aub/handoffs/<screen-id>.aub.zip.'),
+    registry: z.string().optional().describe('Optional aub.registry.json path to include and validate.'),
+    overwrite: z.boolean().optional().describe('Replace an existing package. Defaults to false.'),
+    viewportImages: z
+        .record(z.string())
+        .optional()
+        .describe('Optional map of viewport id to PNG data URL for screenshot evidence.'),
+};
+export const config = {
+    title: 'Export Handoff Package',
+    description: 'Validate a Blueprint and write a complete .aub.zip agent handoff package inside the workspace, including prompts, report contract, optional component registry, and optional viewport screenshots.',
+    inputSchema,
+};
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function run(ctx, args) {
+    if (!args.ref)
+        throw new Error('Provide a Blueprint "ref".');
+    const { blueprint, entry } = await resolveBlueprint(ctx.root, args.ref);
+    const schemaOk = ctx.validators.validateBlueprint(blueprint);
+    const schemaErrors = schemaOk ? [] : formatAjvErrors(ctx.validators.validateBlueprint);
+    const knownTypes = await buildKnownTypes({
+        extensionPath: args.registry ? resolveWorkspacePath(ctx.root, args.registry) : null,
+        startDir: dirname(entry.absPath),
+    });
+    const semanticErrors = schemaOk
+        ? validateBlueprintSemantics(blueprint, { knownTypes: knownTypes.knownTypes })
+        : [];
+    if (!schemaOk || semanticErrors.length > 0) {
+        throw new Error(`Blueprint validation failed:\n${[...schemaErrors, ...semanticErrors].map((item) => `- ${item}`).join('\n')}`);
+    }
+    const outputRef = args.output ?? `.aub/handoffs/${blueprint.screen.id}.aub.zip`;
+    if (!outputRef.endsWith('.aub.zip'))
+        throw new Error('Handoff output must end in .aub.zip.');
+    const outputPath = resolveWorkspacePath(ctx.root, outputRef);
+    if (!args.overwrite && (await exists(outputPath))) {
+        throw new Error(`Refusing to overwrite existing file: ${outputRef}`);
+    }
+    const repoRoot = findRepoRoot();
+    const [agentGuide, agentGuideZhHant, extensionRegistry] = await Promise.all([
+        readFile(resolve(repoRoot, 'docs/agent-handoff.md'), 'utf8'),
+        readFile(resolve(repoRoot, 'docs/agent-handoff.zh-Hant.md'), 'utf8'),
+        knownTypes.extensionPath ? readFile(knownTypes.extensionPath, 'utf8') : Promise.resolve(undefined),
+    ]);
+    const { bytes, manifest } = await createHandoffArchive({
+        blueprint,
+        markdown: exportMarkdown(blueprint),
+        genericPrompt: exportAgentPrompt(blueprint, { adapter: 'generic', task: 'implement' }),
+        codexPrompt: exportAgentPrompt(blueprint, { adapter: 'codex', task: 'implement' }),
+        agentGuide,
+        agentGuideZhHant,
+        reportTemplate: createImplementationReportTemplate(blueprint),
+        reportSchema: ctx.validators.reportSchema,
+        viewportImages: args.viewportImages ?? {},
+        extensionRegistry,
+    });
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, bytes);
+    return {
+        savedPath: relative(ctx.root, outputPath).split(sep).join('/'),
+        screenId: blueprint.screen.id,
+        bytes: bytes.byteLength,
+        sha256: createHash('sha256').update(bytes).digest('hex'),
+        manifest,
+    };
+}

package/vendor/aub/apps/mcp-server/dist/tools/export-prompt.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { resolveBlueprint } from '../workspace.js';
+import { exportAgentPrompt, supportedAgentAdapters, supportedAgentTasks } from '../aub.js';
+export const name = 'export_prompt';
+const inputSchema = {
+    ref: z.string().describe('Blueprint file path or screen id.'),
+    adapter: z
+        .string()
+        .optional()
+        .describe('Agent adapter: generic | codex | claude-code | copilot. Defaults to generic.'),
+    task: z
+        .string()
+        .optional()
+        .describe('Prompt task: author | plan | implement | review. Defaults to implement.'),
+};
+export const config = {
+    title: 'Export Agent Prompt',
+    description: 'Generate an agent-ready prompt (with embedded Blueprint context) for a given adapter and task.',
+    inputSchema,
+};
+export async function run(ctx, args) {
+    const adapter = args.adapter ?? 'generic';
+    const task = args.task ?? 'implement';
+    const adapters = supportedAgentAdapters();
+    const tasks = supportedAgentTasks();
+    if (!adapters.includes(adapter)) {
+        throw new Error(`Unknown adapter "${adapter}". Supported: ${adapters.join(', ')}.`);
+    }
+    if (!tasks.includes(task)) {
+        throw new Error(`Unknown task "${task}". Supported: ${tasks.join(', ')}.`);
+    }
+    const { blueprint, entry } = await resolveBlueprint(ctx.root, args.ref);
+    const prompt = exportAgentPrompt(blueprint, { adapter, task });
+    return { screenId: entry.screenId, path: entry.path, adapter, task, prompt };
+}

package/vendor/aub/apps/mcp-server/dist/tools/export-template-authoring-prompt.js

@@ -0,0 +1,13 @@
+import { templateAuthoringPrompt } from '../aub.js';
+export const name = 'export_template_authoring_prompt';
+export const config = {
+    title: 'Export Template Authoring Prompt',
+    description: 'Return the agent-facing contract for scanning existing apps into AUB workspace templates and component candidates.',
+    inputSchema: {},
+};
+export async function run(_ctx) {
+    return {
+        format: 'markdown',
+        prompt: templateAuthoringPrompt(),
+    };
+}

package/vendor/aub/apps/mcp-server/dist/tools/generate-template-from-source.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { generateTemplateFromSource } from '../aub.js';
+export const name = 'generate_template_from_source';
+const inputSchema = {
+    sourcePath: z.string().describe('Workspace-relative route or component source file path.'),
+    name: z.string().optional().describe('Template display name. Defaults to the source filename.'),
+    id: z.string().optional().describe('Stable template id. Defaults to a slug derived from framework and name.'),
+    category: z.string().optional().describe('Template category. Defaults to workspace.'),
+    framework: z.string().optional().describe('Framework label. Defaults to path-based inference.'),
+    route: z.string().optional().describe('Application route represented by the source. Defaults to path-based inference.'),
+    sourceKind: z.string().optional().describe('Source kind such as route or component. Defaults to source-file.'),
+    output: z
+        .string()
+        .optional()
+        .describe('Destination .aub.template.json path inside the workspace. Defaults to .aub/templates/<id>.aub.template.json.'),
+    status: z.enum(['candidate', 'approved']).optional().describe('Initial template status. Defaults to candidate.'),
+};
+export const config = {
+    title: 'Generate Template From Source',
+    description: 'Generate a candidate AUB workspace template from a static route/component source file and save it under .aub/templates.',
+    inputSchema,
+};
+export async function run(ctx, args) {
+    return generateTemplateFromSource(ctx.root, args ?? {});
+}

package/vendor/aub/apps/mcp-server/dist/tools/get-aub-session.js

@@ -0,0 +1,13 @@
+import { readAubSession } from '../aub.js';
+export const name = 'get_aub_session';
+export const config = {
+    title: 'Get AUB Session',
+    description: 'Read .aub/session.json so an agent can see which Blueprint/project/preview route the user is actively editing.',
+    inputSchema: {},
+};
+export async function run(ctx) {
+    return {
+        path: '.aub/session.json',
+        session: await readAubSession(ctx.root),
+    };
+}

package/vendor/aub/apps/mcp-server/dist/tools/get-blueprint.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import yaml from 'js-yaml';
+import { resolveBlueprint } from '../workspace.js';
+import { exportMarkdown } from '../aub.js';
+export const name = 'get_blueprint';
+const inputSchema = {
+    ref: z.string().describe('Blueprint file path (relative to the workspace root) or screen id.'),
+    format: z
+        .enum(['json', 'yaml', 'markdown'])
+        .optional()
+        .describe('Output format. Defaults to json. markdown returns the derived .ui.md agent context.'),
+};
+export const config = {
+    title: 'Get Blueprint',
+    description: 'Resolve a Blueprint by file path or screen id and return it as JSON, YAML, or derived Markdown agent context.',
+    inputSchema,
+};
+export async function run(ctx, args) {
+    const { blueprint, entry } = await resolveBlueprint(ctx.root, args.ref);
+    const format = args.format ?? 'json';
+    if (format === 'markdown') {
+        return { format, path: entry.path, screenId: entry.screenId, content: exportMarkdown(blueprint) };
+    }
+    if (format === 'yaml') {
+        return { format, path: entry.path, screenId: entry.screenId, content: yaml.dump(blueprint) };
+    }
+    return { format, path: entry.path, screenId: entry.screenId, blueprint };
+}

package/vendor/aub/apps/mcp-server/dist/tools/get-project.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { relative, sep } from 'node:path';
+import { resolveProjectRef } from '../workspace.js';
+import { loadProject, mergeDesignSystem } from '../aub.js';
+export const name = 'get_project';
+const inputSchema = {
+    ref: z.string().describe('Project file path (relative to the workspace root) or project id.'),
+    inlineScreens: z
+        .boolean()
+        .optional()
+        .describe('When true, include each member screen Blueprint inline along with its merged design system. Defaults to false (refs only).'),
+};
+export const config = {
+    title: 'Get Project',
+    description: 'Resolve a multi-screen project by file path or id and return its metadata plus member screens. Pass inlineScreens to embed each full member Blueprint.',
+    inputSchema,
+};
+export async function run(ctx, args) {
+    if (!args.ref) {
+        throw new Error('Provide a project "ref" (file path or project id).');
+    }
+    const { projectPath } = await resolveProjectRef(ctx.root, args.ref);
+    const loaded = await loadProject(projectPath);
+    const inline = args.inlineScreens === true;
+    const screens = loaded.screens.map((screen) => {
+        const base = {
+            id: screen.ref?.id ?? '',
+            name: screen.ref?.name ?? '',
+            path: screen.path,
+            loaded: screen.blueprint != null,
+        };
+        if (inline && screen.blueprint) {
+            base.blueprint = screen.blueprint;
+            base.mergedDesignSystem = mergeDesignSystem(loaded.project, screen.blueprint);
+        }
+        return base;
+    });
+    const source = relative(ctx.root, loaded.projectPath).split(sep).join('/');
+    return {
+        source,
+        project: loaded.project,
+        screens,
+        loadErrors: loaded.errors,
+    };
+}

package/vendor/aub/apps/mcp-server/dist/tools/get-workspace-status.js

@@ -0,0 +1,10 @@
+import { getWorkspaceStatus } from '../aub.js';
+export const name = 'get_workspace_status';
+export const config = {
+    title: 'Get Workspace Status',
+    description: 'Return AUB workspace-loop status: detected frameworks/routes, current session, workspace templates, and component candidates.',
+    inputSchema: {},
+};
+export async function run(ctx) {
+    return getWorkspaceStatus(ctx.root);
+}