@a13xu/lucid 1.10.0 → 1.11.0

package/README.md

@@ -53,7 +53,7 @@ Default DB path: `~/.claude/memory.db`
 6. "What do we know?"  → recall("query")          → knowledge graph search
 ```
 
-## Tools (20)
+## Tools (30)
 
 ### Memory
 | Tool | Description |
@@ -99,6 +99,20 @@ Default DB path: `~/.claude/memory.db`
 | `coding_rules` | Get the 25 Golden Rules checklist — naming, single responsibility, file/function size, error handling, frontend component rules, architecture separation. |
 | `check_code_quality` | Analyze a file or snippet against the 25 Golden Rules. Detects file/function bloat, vague naming, deep nesting, dead code, and for React/Vue files: prop explosion, inline styles, fetch-in-component, direct DOM access. Complements `validate_file`. |
 
+### Web Dev Skills
+| Tool | Description |
+|---|---|
+| `generate_component` | Generate a complete component scaffold from a natural language description. Supports React (TSX/JSX) and Vue/Nuxt (`<script setup>` Composition API). Styling: Tailwind, CSS Modules, or none. |
+| `scaffold_page` | Generate a full page with layout, SEO head, and placeholder sections. Supports Nuxt (`useHead`), Next.js (`Metadata` API), and plain Vue. |
+| `seo_meta` | Generate complete SEO metadata: HTML meta tags, Open Graph, Twitter Card, and JSON-LD structured data (Article, Product, WebSite, WebPage). |
+| `accessibility_audit` | Audit HTML/JSX/Vue snippets for WCAG A/AA/AAA violations. Checks missing alt text, unlabeled inputs, empty buttons/links, positive tabindex, non-interactive click handlers, and more. Returns severity + corrected code. |
+| `api_client` | Generate a typed TypeScript async fetch function for a REST endpoint. Includes error handling (throws on non-2xx), full type aliases, and a usage example. Auth: Bearer, cookie, API key, or none. |
+| `test_generator` | Generate a complete test file covering happy path, edge cases, error path, and mock setup. Frameworks: Vitest, Jest, Playwright. Component testing: Vue Test Utils or React Testing Library. |
+| `responsive_layout` | Generate a mobile-first responsive layout from a wireframe description. Output: Tailwind utility classes, CSS Grid with named areas, or Flexbox + media queries. Container types: full, centered, sidebar. |
+| `security_scan` | Scan JS/TS/HTML/Vue for web security vulnerabilities: XSS, eval/injection, SQL injection, hardcoded secrets, open redirects, prototype pollution, path traversal, insecure CORS. Context-aware (frontend/backend/api). |
+| `design_tokens` | Generate a complete design token set from a brand color and mood. Produces 11-step color scales (50–950), neutral scale, semantic aliases, typography, spacing, radius, and shadows. Output: CSS variables, Tailwind config, or JSON. |
+| `perf_hints` | Analyze a component or page for Core Web Vitals issues (LCP, CLS, INP) and perf anti-patterns: missing image dimensions, render-blocking scripts, fetch-in-render, heavy click handlers, missing useMemo/computed, whole-library imports. |
+
 ## Token optimization in depth
 
 ### How `get_context` works

package/build/index.js

@@ -21,6 +21,7 @@ import { handleGetContext, GetContextSchema, handleGetRecent, GetRecentSchema, }
 import { handleReward, RewardSchema, handlePenalize, PenalizeSchema, handleShowRewards, ShowRewardsSchema, } from "./tools/reward.js";
 import { handleGetCodingRules, handleCheckCodeQuality, CheckCodeQualitySchema, } from "./tools/coding-guard.js";
 import { handlePlanCreate, PlanCreateSchema, handlePlanList, PlanListSchema, handlePlanGet, PlanGetSchema, handlePlanUpdateTask, PlanUpdateTaskSchema, } from "./tools/plan.js";
+import { GenerateComponentSchema, handleGenerateComponent, ScaffoldPageSchema, handleScaffoldPage, SeoMetaSchema, handleSeoMeta, AccessibilityAuditSchema, handleAccessibilityAudit, ApiClientSchema, handleApiClient, TestGeneratorSchema, handleTestGenerator, ResponsiveLayoutSchema, handleResponsiveLayout, SecurityScanSchema, handleSecurityScan, DesignTokensSchema, handleDesignTokens, PerfHintsSchema, handlePerfHints, } from "./tools/webdev/index.js";
 // ---------------------------------------------------------------------------
 // Init DB
 // ---------------------------------------------------------------------------
@@ -53,7 +54,7 @@ else {
 // ---------------------------------------------------------------------------
 // MCP Server
 // ---------------------------------------------------------------------------
-const server = new Server({ name: "lucid", version: "1.10.0" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "lucid", version: "1.11.0" }, { capabilities: { tools: {} } });
 // ---------------------------------------------------------------------------
 // Tool definitions
 // ---------------------------------------------------------------------------
@@ -392,6 +393,172 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["task_id", "status"],
             },
         },
+        // ── Web Dev Skills ───────────────────────────────────────────────────────
+        {
+            name: "generate_component",
+            description: "Generate a complete component scaffold from a natural language description. " +
+                "Supports React (TSX/JSX) and Vue/Nuxt (Composition API + <script setup>). " +
+                "Styling options: Tailwind CSS, CSS Modules, or none.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    description: { type: "string", description: "Natural language description of the component" },
+                    framework: { type: "string", enum: ["react", "vue", "nuxt"], description: "Target framework" },
+                    styling: { type: "string", enum: ["tailwind", "css-modules", "none"], description: "Styling approach" },
+                    typescript: { type: "boolean", description: "Whether to use TypeScript" },
+                },
+                required: ["description", "framework", "styling", "typescript"],
+            },
+        },
+        {
+            name: "scaffold_page",
+            description: "Generate a full page scaffold with layout, SEO head meta, and placeholder sections. " +
+                "Supports Nuxt (useHead), Next.js (Metadata API), and plain Vue.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    page_name: { type: "string", description: "Page name (e.g. About, Dashboard)" },
+                    framework: { type: "string", enum: ["nuxt", "next", "vue"], description: "Target framework" },
+                    sections: { type: "array", items: { type: "string" }, description: "Section names (e.g. hero, features, footer)" },
+                    seo_title: { type: "string", description: "Optional SEO title" },
+                },
+                required: ["page_name", "framework", "sections"],
+            },
+        },
+        {
+            name: "seo_meta",
+            description: "Generate complete SEO metadata for a page: HTML meta tags, Open Graph, Twitter Card, " +
+                "and JSON-LD structured data (Article, Product, WebSite, or WebPage).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    title: { type: "string", description: "Page title" },
+                    description: { type: "string", description: "Meta description (≤160 chars recommended)" },
+                    keywords: { type: "array", items: { type: "string" }, description: "SEO keywords" },
+                    page_type: { type: "string", enum: ["article", "product", "landing", "home"], description: "Page type for JSON-LD" },
+                    url: { type: "string", description: "Canonical page URL" },
+                    image_url: { type: "string", description: "OG/Twitter image URL" },
+                },
+                required: ["title", "description", "keywords", "page_type"],
+            },
+        },
+        {
+            name: "accessibility_audit",
+            description: "Audit HTML, JSX, or Vue template snippets for WCAG accessibility violations. " +
+                "Checks: missing alt text, unlabeled inputs, empty buttons/links, positive tabindex, " +
+                "non-interactive click handlers, open-in-new-tab links, and more. " +
+                "Returns severity (critical/warning/info), WCAG criterion, and corrected code.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: { type: "string", description: "HTML, JSX, or Vue snippet to audit" },
+                    wcag_level: { type: "string", enum: ["A", "AA", "AAA"], description: "WCAG conformance level" },
+                    framework: { type: "string", enum: ["html", "jsx", "vue"], description: "Code framework" },
+                },
+                required: ["code", "wcag_level", "framework"],
+            },
+        },
+        {
+            name: "api_client",
+            description: "Generate a typed TypeScript async function for a REST API endpoint. " +
+                "Includes full types, error handling (throws on non-2xx), and a usage example. " +
+                "Auth strategies: Bearer token, cookie, API key, or none.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    endpoint: { type: "string", description: "API endpoint path (e.g. /users/:id)" },
+                    method: { type: "string", enum: ["GET", "POST", "PUT", "PATCH", "DELETE"] },
+                    request_schema: { type: "string", description: "TypeScript type for request body" },
+                    response_schema: { type: "string", description: "TypeScript type for response" },
+                    auth: { type: "string", enum: ["bearer", "cookie", "apikey", "none"] },
+                    base_url_var: { type: "string", description: "Env var name for base URL (e.g. NEXT_PUBLIC_API_URL)" },
+                },
+                required: ["endpoint", "method", "auth"],
+            },
+        },
+        {
+            name: "test_generator",
+            description: "Generate a complete test file for a function, component, or API handler. " +
+                "Covers: happy path, edge cases (empty/null/boundary), error path, and mock setup. " +
+                "Frameworks: Vitest, Jest, or Playwright (e2e). " +
+                "Component testing: Vue Test Utils or React Testing Library.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: { type: "string", description: "Source code to generate tests for" },
+                    test_framework: { type: "string", enum: ["vitest", "jest", "playwright"] },
+                    test_type: { type: "string", enum: ["unit", "integration", "e2e"] },
+                    component_framework: { type: "string", enum: ["vue", "react", "none"] },
+                },
+                required: ["code", "test_framework", "test_type"],
+            },
+        },
+        {
+            name: "responsive_layout",
+            description: "Generate a responsive mobile-first layout from a wireframe description. " +
+                "Outputs: Tailwind CSS utility classes, CSS Grid with named areas, or Flexbox with media queries. " +
+                "Container types: full-width, centered max-width, or sidebar layout.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    description: { type: "string", description: "Wireframe description (e.g. 'sidebar + main + right panel')" },
+                    framework: { type: "string", enum: ["tailwind", "css-grid", "flexbox"] },
+                    breakpoints: { type: "array", items: { type: "string" }, description: "Breakpoint names (e.g. ['mobile', 'tablet', 'desktop'])" },
+                    container: { type: "string", enum: ["full", "centered", "sidebar"] },
+                },
+                required: ["description", "framework", "breakpoints"],
+            },
+        },
+        {
+            name: "security_scan",
+            description: "Scan JavaScript/TypeScript/HTML/Vue code for common web security vulnerabilities. " +
+                "Detects: XSS (innerHTML, v-html, dangerouslySetInnerHTML), code injection (eval, new Function), " +
+                "SQL injection, hardcoded secrets, open redirects, prototype pollution, path traversal, " +
+                "render-blocking scripts, and insecure CORS. Context-aware: frontend vs backend vs API rules. " +
+                "Complements validate_file (logic drift) — this focuses on web security patterns.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: { type: "string", description: "Code snippet to scan" },
+                    language: { type: "string", enum: ["javascript", "typescript", "html", "vue"] },
+                    context: { type: "string", enum: ["frontend", "backend", "api"] },
+                },
+                required: ["code", "language", "context"],
+            },
+        },
+        {
+            name: "design_tokens",
+            description: "Generate a complete design system token set from a brand color and mood. " +
+                "Produces: 11-step color scales (50–950), neutral scale, semantic color aliases, " +
+                "typography scale, spacing, border-radius, and shadow tokens. " +
+                "Output formats: CSS custom properties, Tailwind config, or JSON.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    brand_name: { type: "string", description: "Brand or project name" },
+                    primary_color: { type: "string", description: "Primary color as hex (#3B82F6) or name (blue)" },
+                    mood: { type: "string", enum: ["minimal", "bold", "playful", "corporate"] },
+                    output_format: { type: "string", enum: ["css-variables", "tailwind-config", "json"] },
+                },
+                required: ["brand_name", "primary_color", "mood", "output_format"],
+            },
+        },
+        {
+            name: "perf_hints",
+            description: "Analyze a component or page file for Core Web Vitals (CWV) and web performance issues. " +
+                "Detects: missing LCP image priority, images without dimensions (CLS), render-blocking scripts, " +
+                "fetch-in-render (TTFB), heavy click handlers (INP), missing useMemo/computed, " +
+                "whole-library imports, and inline style objects. Issues ranked by CWV metric impact.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: { type: "string", description: "Component or page source code to analyze" },
+                    framework: { type: "string", enum: ["react", "vue", "nuxt", "vanilla"] },
+                    context: { type: "string", enum: ["component", "page", "layout"] },
+                },
+                required: ["code", "framework", "context"],
+            },
+        },
     ],
 }));
 // ---------------------------------------------------------------------------
@@ -487,6 +654,37 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "plan_update_task":
                 text = handlePlanUpdateTask(stmts, PlanUpdateTaskSchema.parse(args));
                 break;
+            // Web Dev Skills
+            case "generate_component":
+                text = handleGenerateComponent(GenerateComponentSchema.parse(args));
+                break;
+            case "scaffold_page":
+                text = handleScaffoldPage(ScaffoldPageSchema.parse(args));
+                break;
+            case "seo_meta":
+                text = handleSeoMeta(SeoMetaSchema.parse(args));
+                break;
+            case "accessibility_audit":
+                text = handleAccessibilityAudit(AccessibilityAuditSchema.parse(args));
+                break;
+            case "api_client":
+                text = handleApiClient(ApiClientSchema.parse(args));
+                break;
+            case "test_generator":
+                text = handleTestGenerator(TestGeneratorSchema.parse(args));
+                break;
+            case "responsive_layout":
+                text = handleResponsiveLayout(ResponsiveLayoutSchema.parse(args));
+                break;
+            case "security_scan":
+                text = handleSecurityScan(SecurityScanSchema.parse(args));
+                break;
+            case "design_tokens":
+                text = handleDesignTokens(DesignTokensSchema.parse(args));
+                break;
+            case "perf_hints":
+                text = handlePerfHints(PerfHintsSchema.parse(args));
+                break;
             default:
                 return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
         }

package/build/instance.d.ts

@@ -0,0 +1,9 @@
+import Database from "better-sqlite3";
+export interface InstanceInfo {
+    instance_id: string;
+    pid: number;
+    label: string;
+}
+export declare function registerInstance(db: Database.Database): InstanceInfo;
+export declare function getInstanceInfo(): InstanceInfo | null;
+export declare function logAction(db: Database.Database, tool_name: string, args: unknown, result_ok: boolean, duration_ms: number): void;

package/build/instance.js

@@ -0,0 +1,78 @@
+import { randomUUID } from "crypto";
+const MAX_ACTIONS_KEPT = 200;
+// Fields whose values may be large blobs — truncate in stored args
+const BLOB_FIELDS = new Set(["code", "content", "observations", "body", "data", "text"]);
+let _instanceInfo = null;
+function sanitizeArgs(args) {
+    if (!args || typeof args !== "object")
+        return JSON.stringify(args ?? {});
+    const copy = {};
+    for (const [k, v] of Object.entries(args)) {
+        if (typeof v === "string" && BLOB_FIELDS.has(k) && v.length > 200) {
+            copy[k] = `[${v.length} chars]`;
+        }
+        else {
+            copy[k] = v;
+        }
+    }
+    return JSON.stringify(copy);
+}
+export function registerInstance(db) {
+    if (_instanceInfo)
+        return _instanceInfo;
+    const instance_id = randomUUID();
+    const pid = process.pid;
+    const label = process.env["LUCID_INSTANCE_LABEL"] ?? "";
+    db.prepare("INSERT OR REPLACE INTO instances (instance_id, pid, label, started_at, last_heartbeat, status) VALUES (?, ?, ?, unixepoch(), unixepoch(), 'active')").run(instance_id, pid, label);
+    _instanceInfo = { instance_id, pid, label };
+    // Prepared statements for heartbeat (compiled once)
+    const hbStmt = db.prepare("UPDATE instances SET last_heartbeat = unixepoch(), status = 'active' WHERE instance_id = ?");
+    const staleStmt = db.prepare("UPDATE instances SET status = 'stale' WHERE status = 'active' AND last_heartbeat < unixepoch() - 45 AND instance_id != ?");
+    const deadStmt = db.prepare("UPDATE instances SET status = 'dead' WHERE status != 'dead' AND last_heartbeat < unixepoch() - 120 AND instance_id != ?");
+    const timer = setInterval(() => {
+        try {
+            hbStmt.run(instance_id);
+            staleStmt.run(instance_id);
+            deadStmt.run(instance_id);
+        }
+        catch { /* suppress — never break the tool handler */ }
+    }, 15_000);
+    timer.unref();
+    const markDead = () => {
+        try {
+            db.prepare("UPDATE instances SET status = 'dead' WHERE instance_id = ?").run(instance_id);
+        }
+        catch { /* suppress */ }
+    };
+    // "exit" fires during an already-in-progress exit — no process.exit() needed
+    process.once("exit", markDead);
+    // SIGTERM/SIGINT: mark dead then let the process exit (must call process.exit()
+    // explicitly, otherwise the signal listener swallows the default exit behaviour)
+    process.once("SIGTERM", () => { markDead(); process.exit(0); });
+    process.once("SIGINT", () => { markDead(); process.exit(0); });
+    console.error(`[lucid] Instance registered: ${instance_id} (PID ${pid})`);
+    return _instanceInfo;
+}
+export function getInstanceInfo() {
+    return _instanceInfo;
+}
+export function logAction(db, tool_name, args, result_ok, duration_ms) {
+    if (!_instanceInfo)
+        return;
+    try {
+        const args_json = sanitizeArgs(args);
+        db.prepare("INSERT INTO instance_actions (instance_id, tool_name, args_json, result_ok, duration_ms) VALUES (?, ?, ?, ?, ?)").run(_instanceInfo.instance_id, tool_name, args_json, result_ok ? 1 : 0, duration_ms);
+        // Keep only the last MAX_ACTIONS_KEPT rows per instance
+        db.prepare(`
+      DELETE FROM instance_actions
+      WHERE instance_id = ?
+        AND id NOT IN (
+          SELECT id FROM instance_actions
+          WHERE instance_id = ?
+          ORDER BY id DESC
+          LIMIT ${MAX_ACTIONS_KEPT}
+        )
+    `).run(_instanceInfo.instance_id, _instanceInfo.instance_id);
+    }
+    catch { /* suppress — never propagate to caller */ }
+}

package/build/tools/e2e.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import type Database from "better-sqlite3";
+import type { Statements } from "../database.js";
+export declare const RunE2eTestSchema: z.ZodObject<{
+    task_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    task_id: number;
+}, {
+    task_id: number;
+}>;
+type RunE2eTestArgs = z.infer<typeof RunE2eTestSchema>;
+export declare function handleRunE2eTest(db: Database.Database, stmts: Statements, args: RunE2eTestArgs): string;
+export {};

package/build/tools/e2e.js

@@ -0,0 +1,109 @@
+import { spawnSync } from "child_process";
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+export const RunE2eTestSchema = z.object({
+    task_id: z.number().int().positive(),
+});
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+export function handleRunE2eTest(db, stmts, args) {
+    const { task_id } = args;
+    const task = stmts.getTaskById.get(task_id);
+    if (!task)
+        return `Error: Task #${task_id} not found.`;
+    if (!task.is_e2e)
+        return `Error: Task #${task_id} is not an E2E task.`;
+    const criteria = task.test_criteria.trim();
+    if (!criteria)
+        return `Error: Task #${task_id} has empty test_criteria.`;
+    const newRetryCount = task.retry_count + 1;
+    // Execute test_criteria as a shell command
+    const result = spawnSync(criteria, {
+        shell: true,
+        timeout: 60_000,
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+    });
+    const exitCode = result.status ?? 1;
+    const stdout = (result.stdout ?? "").trim();
+    const stderr = (result.stderr ?? "").trim();
+    const timedOut = result.error?.message?.includes("ETIMEDOUT") ||
+        result.signal === "SIGTERM";
+    const passed = exitCode === 0 && !timedOut;
+    const e2eResult = passed ? "pass" : "fail";
+    let e2eError = null;
+    if (!passed) {
+        const parts = [];
+        if (timedOut)
+            parts.push("Timed out after 60s");
+        if (stderr)
+            parts.push(stderr);
+        if (!timedOut && !stderr && stdout)
+            parts.push(stdout);
+        if (result.error && !timedOut)
+            parts.push(result.error.message);
+        e2eError = parts.filter(Boolean).join("\n") || `Exit code: ${exitCode}`;
+    }
+    // Update e2e_result, e2e_error, retry_count in DB
+    stmts.updateTaskE2eResult.run(e2eResult, e2eError, newRetryCount, task_id);
+    // If passed, also mark the task as done
+    if (passed) {
+        const plan = stmts.getPlanById.get(task.plan_id);
+        const maxRetries = plan?.max_retries ?? 3;
+        let notes = [];
+        try {
+            notes = JSON.parse(task.notes);
+        }
+        catch { /* ignore */ }
+        notes.push({ text: `E2E passed on attempt ${newRetryCount}`, ts: Math.floor(Date.now() / 1000) });
+        stmts.updateTaskStatus.run("done", JSON.stringify(notes), task_id);
+        const remaining = stmts.countRemainingTasks.get(task.plan_id);
+        if (remaining && remaining.count === 0) {
+            stmts.updatePlanStatus.run("completed", task.plan_id);
+        }
+        const lines = [
+            `[E2E PASS] Task #${task_id} — ${task.title}`,
+            `Attempt: ${newRetryCount}`,
+        ];
+        if (stdout)
+            lines.push(`Output: ${stdout}`);
+        lines.push(`Task status updated to done.`);
+        if (remaining && remaining.count === 0) {
+            lines.push(`Plan #${task.plan_id} completed.`);
+        }
+        return lines.join("\n");
+    }
+    // Failed — check retry budget
+    const plan = stmts.getPlanById.get(task.plan_id);
+    const maxRetries = plan?.max_retries ?? 3;
+    const retriesLeft = maxRetries - newRetryCount;
+    const lines = [
+        `[E2E FAIL] Task #${task_id} — ${task.title}`,
+        `Attempt: ${newRetryCount}/${maxRetries}`,
+        `Error: ${e2eError ?? "unknown"}`,
+    ];
+    if (stdout)
+        lines.push(`Stdout: ${stdout}`);
+    if (retriesLeft > 0) {
+        // Create a [FIX] remediation task for this iteration
+        const errorSummary = (e2eError ?? "unknown error").slice(0, 100).replace(/\n/g, " ");
+        const fixTitle = `[FIX] Iteration ${newRetryCount}: ${errorSummary}`;
+        const fixDescription = `Fix the E2E failure from iteration ${newRetryCount}.\nError: ${e2eError ?? "unknown"}\nAfter fixing, mark this task done to trigger automatic E2E re-run.`;
+        const maxSeqRow = stmts.getMaxSeqForPlan.get(task.plan_id);
+        const nextSeq = (maxSeqRow?.max_seq ?? 0) + 1;
+        const fixResult = stmts.insertFixTask.run(task.plan_id, nextSeq, fixTitle, fixDescription, task.test_criteria, task_id);
+        const fixTaskId = fixResult.lastInsertRowid;
+        lines.push(`Retries left: ${retriesLeft}.`);
+        lines.push(`Created [FIX] task #${fixTaskId} "${fixTitle}".`);
+        lines.push(`Fix the issue and mark task #${fixTaskId} done — this will automatically re-run the E2E test.`);
+    }
+    else {
+        // Exhausted all retries — mark plan as e2e_failed
+        stmts.updatePlanStatus.run("e2e_failed", task.plan_id);
+        lines.push(`No retries left. Plan #${task.plan_id} marked as e2e_failed.`);
+    }
+    return lines.join("\n");
+}

package/build/tools/webdev/accessibility-audit.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const AccessibilityAuditSchema: z.ZodObject<{
+    code: z.ZodString;
+    wcag_level: z.ZodEnum<["A", "AA", "AAA"]>;
+    framework: z.ZodEnum<["html", "jsx", "vue"]>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    framework: "vue" | "jsx" | "html";
+    wcag_level: "A" | "AA" | "AAA";
+}, {
+    code: string;
+    framework: "vue" | "jsx" | "html";
+    wcag_level: "A" | "AA" | "AAA";
+}>;
+export type A11ySeverity = "critical" | "warning" | "info";
+export interface A11yIssue {
+    line: number;
+    severity: A11ySeverity;
+    criterion: string;
+    message: string;
+    fix: string;
+}
+export declare function handleAccessibilityAudit(args: z.infer<typeof AccessibilityAuditSchema>): string;