@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/tools/inspect/executor.js

@@ -0,0 +1,142 @@
+import { summarizeError } from '../../utils/error-display.js';
+import { createInspectFailure, createInspectSuccess, requireExistingFilePath, safeRead, readRequiredFile, } from './shared.js';
+import { detectProject, inspectApi, parsePrismaSchema, generateApiSpec, validateApiSpec, inspectApiSync, buildScaffold, } from './project.js';
+import { inspectComponents, inspectLayout, inspectAccessibility, inspectComponentState, inspectRenderTriggers, inspectHooks, inspectOverflow, inspectSizing, inspectStacking, inspectResponsive, inspectEvents, inspectTailwind, inspectClientBoundary, inspectErrorBoundary, } from './frontend.js';
+export async function executeInspectMode(input, projectRoot, format) {
+    try {
+        switch (input.mode) {
+            case 'project':
+                return createInspectSuccess(detectProject(projectRoot), format, input.mode);
+            case 'api': {
+                const framework = (input.framework ?? 'auto');
+                const routes = await inspectApi(projectRoot, framework);
+                return createInspectSuccess({ routes, count: routes.length }, format, input.mode);
+            }
+            case 'database': {
+                const schemaPath = input.schemaPath
+                    ? requireExistingFilePath(projectRoot, input.schemaPath, 'Database schema not found at')
+                    : requireExistingFilePath(projectRoot, 'prisma/schema.prisma', 'Database schema not found at');
+                return createInspectSuccess(parsePrismaSchema(safeRead(schemaPath)), format, input.mode);
+            }
+            case 'components': {
+                const file = readRequiredFile(projectRoot, input.file, 'components', 'File not found');
+                if ('success' in file)
+                    return file;
+                const comps = inspectComponents(file.content);
+                return createInspectSuccess({ components: comps, count: comps.length }, format, input.mode);
+            }
+            case 'layout': {
+                const file = readRequiredFile(projectRoot, input.file, 'layout', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectLayout(file.content, input.file), format, input.mode);
+            }
+            case 'accessibility': {
+                const file = readRequiredFile(projectRoot, input.file, 'accessibility', 'File not found');
+                if ('success' in file)
+                    return file;
+                const a11yIssues = inspectAccessibility(file.content);
+                return createInspectSuccess({ issues: a11yIssues, count: a11yIssues.length }, format, input.mode);
+            }
+            case 'api_spec': {
+                const framework = (input.framework ?? 'auto');
+                const routes = await inspectApi(projectRoot, framework);
+                return createInspectSuccess(generateApiSpec(routes), format, input.mode);
+            }
+            case 'api_validate': {
+                if (!input.specPath) {
+                    return createInspectFailure('specPath is required for api_validate mode');
+                }
+                const resolvedSpec = readRequiredFile(projectRoot, input.specPath, 'api_validate', 'Spec file not found at');
+                if ('success' in resolvedSpec)
+                    return resolvedSpec;
+                const framework = (input.framework ?? 'auto');
+                const routes = await inspectApi(projectRoot, framework);
+                return createInspectSuccess(validateApiSpec(resolvedSpec.content, routes), format, input.mode);
+            }
+            case 'api_sync': {
+                const framework = (input.framework ?? 'auto');
+                return createInspectSuccess(await inspectApiSync(projectRoot, framework), format, input.mode);
+            }
+            case 'scaffold': {
+                if (!input.moduleName) {
+                    return createInspectFailure('moduleName is required for scaffold mode');
+                }
+                const dryRun = input.dryRun !== false;
+                return createInspectSuccess(buildScaffold(input.moduleName, projectRoot, dryRun), format, input.mode);
+            }
+            case 'component_state': {
+                const file = readRequiredFile(projectRoot, input.file, 'component_state', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectComponentState(file.content, input.file), format, input.mode);
+            }
+            case 'render_triggers': {
+                const file = readRequiredFile(projectRoot, input.file, 'render_triggers', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectRenderTriggers(file.content, input.file), format, input.mode);
+            }
+            case 'hooks': {
+                const file = readRequiredFile(projectRoot, input.file, 'hooks', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectHooks(file.content, input.file), format, input.mode);
+            }
+            case 'overflow': {
+                const file = readRequiredFile(projectRoot, input.file, 'overflow', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectOverflow(file.content, input.file), format, input.mode);
+            }
+            case 'sizing': {
+                const file = readRequiredFile(projectRoot, input.file, 'sizing', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectSizing(file.content, input.file), format, input.mode);
+            }
+            case 'stacking': {
+                const file = readRequiredFile(projectRoot, input.file, 'stacking', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectStacking(file.content, input.file), format, input.mode);
+            }
+            case 'responsive': {
+                const file = readRequiredFile(projectRoot, input.file, 'responsive', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectResponsive(file.content, input.file), format, input.mode);
+            }
+            case 'events': {
+                const file = readRequiredFile(projectRoot, input.file, 'events', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectEvents(file.content, input.file), format, input.mode);
+            }
+            case 'tailwind': {
+                const file = readRequiredFile(projectRoot, input.file, 'tailwind', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectTailwind(file.content, input.file), format, input.mode);
+            }
+            case 'client_boundary': {
+                const file = readRequiredFile(projectRoot, input.file, 'client_boundary', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectClientBoundary(file.content, input.file), format, input.mode);
+            }
+            case 'error_boundary': {
+                const file = readRequiredFile(projectRoot, input.file, 'error_boundary', 'File not found');
+                if ('success' in file)
+                    return file;
+                return createInspectSuccess(inspectErrorBoundary(file.content, input.file), format, input.mode);
+            }
+            default:
+                return createInspectFailure(`Unknown mode: ${input.mode}`);
+        }
+    }
+    catch (err) {
+        const message = summarizeError(err);
+        return { success: false, error: `inspect (${input.mode}): ${message}` };
+    }
+}

package/dist/platform/tools/inspect/frontend.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentInfo, LayoutInfo, A11yIssue, ComponentStateInfo, RenderTriggersInfo, HooksInfo, OverflowInfo, SizingInfo, StackingInfo, ResponsiveInfo, EventsInfo, TailwindInfo, ClientBoundaryInfo, ErrorBoundaryInfo } from './schema.js';
+export declare function inspectComponents(content: string): ComponentInfo[];
+export declare function inspectLayout(content: string, file: string): LayoutInfo;
+export declare function inspectAccessibility(content: string): A11yIssue[];
+export declare function inspectComponentState(content: string, file: string): ComponentStateInfo;
+export declare function inspectRenderTriggers(content: string, file: string): RenderTriggersInfo;
+export declare function inspectHooks(content: string, file: string): HooksInfo;
+export declare function inspectOverflow(content: string, file: string): OverflowInfo;
+export declare function inspectSizing(content: string, file: string): SizingInfo;
+export declare function inspectStacking(content: string, file: string): StackingInfo;
+export declare function inspectResponsive(content: string, file: string): ResponsiveInfo;
+export declare function inspectEvents(content: string, file: string): EventsInfo;
+export declare function inspectTailwind(content: string, file: string): TailwindInfo;
+export declare function inspectClientBoundary(content: string, file: string): ClientBoundaryInfo;
+export declare function inspectErrorBoundary(content: string, file: string): ErrorBoundaryInfo;
+//# sourceMappingURL=frontend.d.ts.map

package/dist/platform/tools/inspect/frontend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontend.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/inspect/frontend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,SAAS,EACT,kBAAkB,EAElB,kBAAkB,EAElB,SAAS,EAET,YAAY,EAEZ,UAAU,EAEV,YAAY,EAEZ,cAAc,EAEd,UAAU,EAEV,YAAY,EAEZ,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAErB,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,CAkFlE;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAgCvE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAwDjE;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAoBvF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAiBvF;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CA4BrE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAkB3E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAkDvE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CA6B3E;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,CAoB/E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAwBvE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAmC3E;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAkBvF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAiBrF"}

package/dist/platform/tools/inspect/frontend.js

@@ -0,0 +1,466 @@
+export function inspectComponents(content) {
+    const components = [];
+    const lines = content.split('\n');
+    const FN_COMP_RE = /^(?:export\s+(?:default\s+)?)?function\s+(\w+)\s*\(/;
+    const ARROW_COMP_RE = /^(?:export\s+(?:const|default)\s+)(\w+)\s*(?::\s*React\.FC[^=]*)?=\s*(?:(?:\([^)]*\)|\w+)\s*=>|React\.memo)/;
+    const CLASS_COMP_RE = /^(?:export\s+(?:default\s+)?)?class\s+(\w+)\s+extends\s+(?:React\.)?(?:Component|PureComponent)/;
+    const HOOK_RE = /\b(use[A-Z]\w*)\s*\(/g;
+    const CHILD_COMP_RE = /<([A-Z]\w*)(?:\s|>|\/)/g;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let name = null;
+        let kind = 'function';
+        let fnMatch = FN_COMP_RE.exec(line);
+        if (fnMatch) {
+            name = fnMatch[1];
+            kind = 'function';
+        }
+        if (!name) {
+            const arrowMatch = ARROW_COMP_RE.exec(line);
+            if (arrowMatch) {
+                name = arrowMatch[1];
+                kind = 'arrow';
+            }
+        }
+        if (!name) {
+            const classMatch = CLASS_COMP_RE.exec(line);
+            if (classMatch) {
+                name = classMatch[1];
+                kind = 'class';
+            }
+        }
+        if (!name || !/^[A-Z]/.test(name))
+            continue;
+        let body = '';
+        const end = Math.min(i + 50, lines.length);
+        for (let j = i; j < end; j++)
+            body += lines[j] + '\n';
+        const hooks = [];
+        const hooksSeen = new Set();
+        let hm;
+        const hookRe = new RegExp(HOOK_RE.source, 'g');
+        while ((hm = hookRe.exec(body)) !== null) {
+            if (!hooksSeen.has(hm[1])) {
+                hooksSeen.add(hm[1]);
+                hooks.push(hm[1]);
+            }
+        }
+        const children = [];
+        const childSeen = new Set();
+        let cm;
+        const childRe = new RegExp(CHILD_COMP_RE.source, 'g');
+        while ((cm = childRe.exec(body)) !== null) {
+            if (!childSeen.has(cm[1]) && cm[1] !== name) {
+                childSeen.add(cm[1]);
+                children.push(cm[1]);
+            }
+        }
+        const props = [];
+        const propLine = lines.slice(i, Math.min(i + 5, lines.length)).join(' ');
+        const PROPS_DESTRUCTURE_RE = /\{\s*([^}]+)\s*\}/;
+        const pm = PROPS_DESTRUCTURE_RE.exec(propLine);
+        if (pm) {
+            props.push(...pm[1]
+                .split(',')
+                .map((p) => p.trim().replace(/[=:][^,]*/g, '').trim())
+                .filter((p) => /^\w+$/.test(p)));
+        }
+        components.push({ name, kind, line: i + 1, props, hooks, children });
+    }
+    return components;
+}
+export function inspectLayout(content, file) {
+    const displays = [];
+    const flex = [];
+    const grid = [];
+    const sizing = [];
+    const overflow = [];
+    const DISPLAY_RE = /\b(flex|grid|block|inline|inline-flex|inline-grid|inline-block|hidden|contents|flow-root)\b/g;
+    const FLEX_RE = /\b(flex-(?:row|col|wrap|nowrap|1|auto|none|grow|shrink)|justify-(?:start|end|center|between|around|evenly)|items-(?:start|end|center|stretch|baseline)|gap-\w+|space-[xy]-\w+|self-\w+)\b/g;
+    const GRID_RE = /\b(grid-cols-\w+|grid-rows-\w+|col-span-\w+|row-span-\w+|place-\w+-\w+)\b/g;
+    const SIZING_RE = /\b(w-\w+|h-\w+|min-w-\w+|min-h-\w+|max-w-\w+|max-h-\w+|size-\w+)\b/g;
+    const OVERFLOW_RE = /\b(overflow-(?:hidden|auto|scroll|visible|x-\w+|y-\w+)|truncate|text-ellipsis|whitespace-\w+)\b/g;
+    const extract = (re, target) => {
+        const seen = new Set();
+        let m;
+        const r = new RegExp(re.source, 'g');
+        while ((m = r.exec(content)) !== null) {
+            if (!seen.has(m[1])) {
+                seen.add(m[1]);
+                target.push(m[1]);
+            }
+        }
+    };
+    extract(DISPLAY_RE, displays);
+    extract(FLEX_RE, flex);
+    extract(GRID_RE, grid);
+    extract(SIZING_RE, sizing);
+    extract(OVERFLOW_RE, overflow);
+    return { file, displays, flex, grid, sizing, overflow };
+}
+export function inspectAccessibility(content) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNo = i + 1;
+        if (/<img\b(?![^>]*\balt=)/i.test(line)) {
+            issues.push({
+                line: lineNo,
+                code: 'img-alt',
+                message: 'img element is missing an alt attribute',
+                wcag: 'WCAG 1.1.1 (Level A)',
+            });
+        }
+        if (/<button\b(?![^>]*(?:aria-label|aria-labelledby|title))/i.test(line)) {
+            const hasContent = />[^<]+<\/button>/i.test(line) || />[^<]+/.test(line);
+            if (!hasContent) {
+                issues.push({
+                    line: lineNo,
+                    code: 'button-name',
+                    message: 'button element may be missing an accessible name',
+                    wcag: 'WCAG 4.1.2 (Level A)',
+                });
+            }
+        }
+        if (/onClick/.test(line)) {
+            if (/<(?:div|span)\b(?![^>]*\brole=)[^>]*onClick/i.test(line)) {
+                issues.push({
+                    line: lineNo,
+                    code: 'click-events-have-key-events',
+                    message: 'Non-interactive element has onClick without a role attribute',
+                    wcag: 'WCAG 4.1.2 (Level A)',
+                });
+            }
+        }
+        if (/<input\b/i.test(line) && !/type=['"]hidden['"]/.test(line)) {
+            if (!/<label/i.test(line) && !/aria-label/.test(line) && !/aria-labelledby/.test(line)) {
+                const context = lines.slice(Math.max(0, i - 3), i + 1).join(' ');
+                if (!/<label/i.test(context) && !/aria-label/.test(context)) {
+                    issues.push({
+                        line: lineNo,
+                        code: 'label',
+                        message: 'input element may be missing an associated label',
+                        wcag: 'WCAG 1.3.1 (Level A)',
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+export function inspectComponentState(content, file) {
+    const lines = content.split('\n');
+    const stateVars = [];
+    const useStateRe = /const\s*\[\s*(\w+)\s*,/;
+    const useContextRe = /(?:const|let|var)\s+(\w+)\s*=\s*useContext\s*\(/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const ln = i + 1;
+        if (/\buseState\s*\(/.test(line)) {
+            const m = useStateRe.exec(line);
+            stateVars.push({ name: m ? m[1] : '(unknown)', kind: 'useState', line: ln });
+        }
+        else if (/\buseReducer\s*\(/.test(line)) {
+            const m = useStateRe.exec(line);
+            stateVars.push({ name: m ? m[1] : '(unknown)', kind: 'useReducer', line: ln });
+        }
+        else if (/\buseContext\s*\(/.test(line)) {
+            const m = useContextRe.exec(line);
+            stateVars.push({ name: m ? m[1] : '(unknown)', kind: 'useContext', line: ln });
+        }
+    }
+    return { file, stateVars, count: stateVars.length };
+}
+export function inspectRenderTriggers(content, file) {
+    const lines = content.split('\n');
+    const triggers = [];
+    const setterRe = /const\s*\[\s*\w+\s*,\s*(set\w+)\s*\]/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const ln = i + 1;
+        if (setterRe.test(line)) {
+            const m = setterRe.exec(line);
+            if (m)
+                triggers.push({ kind: 'state_setter', name: m[1], line: ln });
+        }
+        if (/\buseEffect\s*\(/.test(line))
+            triggers.push({ kind: 'effect_dep', name: 'useEffect', line: ln });
+        if (/\buseMemo\s*\(/.test(line))
+            triggers.push({ kind: 'memo_dep', name: 'useMemo', line: ln });
+        if (/\buseCallback\s*\(/.test(line))
+            triggers.push({ kind: 'callback_dep', name: 'useCallback', line: ln });
+        if (/(?:React\.memo|\bmemo)\s*\(/.test(line))
+            triggers.push({ kind: 'memo_boundary', name: 'memo', line: ln });
+    }
+    return { file, triggers, count: triggers.length };
+}
+export function inspectHooks(content, file) {
+    const lines = content.split('\n');
+    const hooks = [];
+    let missingDepsCount = 0;
+    const hookRe = /\b(useEffect|useMemo|useCallback)\s*\(/;
+    const inlineDepsRe = /[},]\s*\[([^\]]*)\]\s*\)/;
+    const skipKeywords = new Set(['useEffect', 'useMemo', 'useCallback', 'return', 'const', 'let', 'var', 'if', 'else', 'for', 'while', 'true', 'false', 'null', 'undefined', 'async', 'await', 'function', 'new', 'this', 'of', 'in', 'console', 'Math', 'JSON', 'Array', 'Object', 'Promise', 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'window', 'document', 'fetch', 'NaN', 'Infinity', 'Error', 'RegExp', 'Date', 'Map', 'Set', 'parseInt', 'parseFloat']);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const hm = hookRe.exec(line);
+        if (!hm)
+            continue;
+        const hookKind = hm[1];
+        const ln = i + 1;
+        const body = lines.slice(i, Math.min(i + 30, lines.length)).join('\n');
+        const dm = inlineDepsRe.exec(body);
+        const deps = dm ? dm[1].split(',').map((d) => d.trim()).filter(Boolean) : [];
+        const callbackBody = body.slice(0, body.lastIndexOf(']'));
+        const usedVarsRe = /\b([a-zA-Z_$][\w$]*)\b/g;
+        const usedVars = new Set();
+        let vm;
+        while ((vm = usedVarsRe.exec(callbackBody)) !== null) {
+            if (!skipKeywords.has(vm[1]) && vm[1].length > 1)
+                usedVars.add(vm[1]);
+        }
+        const missing = [...usedVars].filter((v) => !deps.includes(v) && /^[a-z]/.test(v)).slice(0, 5);
+        if (missing.length)
+            missingDepsCount++;
+        hooks.push({ hookKind, line: ln, deps, missing });
+    }
+    return { file, hooks, missingDepsCount };
+}
+export function inspectOverflow(content, file) {
+    const lines = content.split('\n');
+    const issues = [];
+    const hasHeightRe = /\b(?:h-|max-h-|height)\b/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const ln = i + 1;
+        if (/\boverflow-hidden\b/.test(line) || /overflow\s*:\s*hidden/.test(line)) {
+            if (!hasHeightRe.test(line)) {
+                issues.push({ line: ln, kind: 'hidden_clip', snippet: line.trim().slice(0, 80) });
+            }
+        }
+        else if (/\b(?:overflow-(?:scroll|auto|y-scroll|y-auto|x-scroll|x-auto))\b/.test(line) || /overflow(?:-y|-x)?\s*:\s*(?:scroll|auto)/.test(line)) {
+            if (!hasHeightRe.test(line)) {
+                issues.push({ line: ln, kind: 'scroll_no_height', snippet: line.trim().slice(0, 80) });
+            }
+        }
+    }
+    return { file, issues, count: issues.length };
+}
+export function inspectSizing(content, file) {
+    const lines = content.split('\n');
+    const items = [];
+    let hardcodedCount = 0;
+    const tailwindFixedRe = /\b(?:w|h|min-w|max-w|min-h|max-h)-(\d+)\b/g;
+    const tailwindPctRe = /\b(?:w|h)-(\d+\/\d+|full|screen)\b/g;
+    const tailwindFlexRe = /\bflex-(?:1|auto|none|initial|grow|shrink)\b/g;
+    const tailwindGridRe = /\bgrid-cols-\d+\b/g;
+    const tailwindVpRe = /\b(?:w|h)-(?:screen|lvh|svh|dvh)\b/g;
+    const cssPxRe = /(?:width|height|min-width|max-width|min-height|max-height)\s*:\s*(\d+)px/g;
+    const cssPctRe = /(?:width|height)\s*:\s*(\d+%)/g;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const ln = i + 1;
+        let m;
+        tailwindFixedRe.lastIndex = 0;
+        while ((m = tailwindFixedRe.exec(line)) !== null) {
+            const val = parseInt(m[1]);
+            const flagged = val > 96;
+            if (flagged)
+                hardcodedCount++;
+            items.push({ line: ln, kind: 'fixed_px', value: m[0], flagged });
+        }
+        tailwindPctRe.lastIndex = 0;
+        while ((m = tailwindPctRe.exec(line)) !== null) {
+            items.push({ line: ln, kind: 'percentage', value: m[0], flagged: false });
+        }
+        tailwindFlexRe.lastIndex = 0;
+        while ((m = tailwindFlexRe.exec(line)) !== null) {
+            items.push({ line: ln, kind: 'flex', value: m[0], flagged: false });
+        }
+        tailwindGridRe.lastIndex = 0;
+        while ((m = tailwindGridRe.exec(line)) !== null) {
+            items.push({ line: ln, kind: 'grid', value: m[0], flagged: false });
+        }
+        tailwindVpRe.lastIndex = 0;
+        while ((m = tailwindVpRe.exec(line)) !== null) {
+            items.push({ line: ln, kind: 'viewport', value: m[0], flagged: false });
+        }
+        cssPxRe.lastIndex = 0;
+        while ((m = cssPxRe.exec(line)) !== null) {
+            const flagged = parseInt(m[1]) > 200;
+            if (flagged)
+                hardcodedCount++;
+            items.push({ line: ln, kind: 'fixed_px', value: m[0], flagged });
+        }
+        cssPctRe.lastIndex = 0;
+        while ((m = cssPctRe.exec(line)) !== null) {
+            items.push({ line: ln, kind: 'percentage', value: m[0], flagged: false });
+        }
+    }
+    return { file, items, hardcodedCount };
+}
+export function inspectStacking(content, file) {
+    const lines = content.split('\n');
+    const zIndexItems = [];
+    const tailwindZRe = /-?z-(\d+|auto)\b/g;
+    const cssZRe = /z-index\s*:\s*(-?\d+)/g;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const ln = i + 1;
+        let m;
+        tailwindZRe.lastIndex = 0;
+        while ((m = tailwindZRe.exec(line)) !== null) {
+            zIndexItems.push({ line: ln, value: m[0], context: line.trim().slice(0, 60) });
+        }
+        cssZRe.lastIndex = 0;
+        while ((m = cssZRe.exec(line)) !== null) {
+            zIndexItems.push({ line: ln, value: m[0], context: line.trim().slice(0, 60) });
+        }
+    }
+    const byValue = new Map();
+    for (const item of zIndexItems) {
+        const existing = byValue.get(item.value) ?? [];
+        existing.push(item.line);
+        byValue.set(item.value, existing);
+    }
+    const potentialConflicts = [];
+    for (const [val, lineNums] of byValue) {
+        if (lineNums.length > 1)
+            potentialConflicts.push({ values: [val], lines: lineNums });
+    }
+    return { file, zIndexItems, potentialConflicts };
+}
+export function inspectResponsive(content, file) {
+    const lines = content.split('\n');
+    const prefixes = ['sm', 'md', 'lg', 'xl', '2xl'];
+    const breakpointMap = new Map();
+    for (const p of prefixes)
+        breakpointMap.set(p, []);
+    const re = /\b(sm|md|lg|xl|2xl):([-\w/[\]]+)/g;
+    for (const line of lines) {
+        re.lastIndex = 0;
+        let m;
+        while ((m = re.exec(line)) !== null) {
+            const arr = breakpointMap.get(m[1]);
+            arr.push(m[0]);
+        }
+    }
+    const breakpoints = [];
+    for (const p of prefixes) {
+        const classes = breakpointMap.get(p);
+        if (classes.length)
+            breakpoints.push({ prefix: p, count: classes.length, classes: [...new Set(classes)].slice(0, 20) });
+    }
+    return { file, breakpoints, hasMobileFirst: (breakpointMap.get('sm')?.length ?? 0) > 0 };
+}
+export function inspectEvents(content, file) {
+    const lines = content.split('\n');
+    const handlers = [];
+    const eventRe = /\bon(Click|Change|Submit|KeyDown|KeyUp|KeyPress|Focus|Blur|MouseEnter|MouseLeave|Input|Scroll|Resize)\s*[={]/gi;
+    const preventDefaultRe = /\.preventDefault\s*\(/;
+    const stopPropagationRe = /\.stopPropagation\s*\(/;
+    const delegationRe = /(?:document|window)\s*\.\s*addEventListener\s*\(/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        eventRe.lastIndex = 0;
+        let m;
+        while ((m = eventRe.exec(line)) !== null) {
+            const ln = i + 1;
+            const ctx = lines.slice(Math.max(0, i - 1), Math.min(lines.length, i + 4)).join('\n');
+            handlers.push({
+                line: ln,
+                event: m[0].slice(0, -1).trim(),
+                hasPreventDefault: preventDefaultRe.test(ctx),
+                hasStopPropagation: stopPropagationRe.test(ctx),
+                isDelegated: delegationRe.test(line),
+            });
+        }
+    }
+    return { file, handlers, count: handlers.length };
+}
+export function inspectTailwind(content, file) {
+    const lines = content.split('\n');
+    const conflicts = [];
+    const conflictGroups = [
+        { pattern: /\bp-(\d+|px|py|\w+)\b/g, name: 'padding' },
+        { pattern: /\bm-(\d+|px|py|auto|\w+)\b/g, name: 'margin' },
+        { pattern: /\btext-(red|blue|green|yellow|purple|pink|gray|black|white|slate|zinc|neutral|stone|orange|amber|lime|emerald|teal|cyan|sky|violet|fuchsia|rose)-(\d+)\b/g, name: 'text-color' },
+        { pattern: /\bbg-(red|blue|green|yellow|purple|pink|gray|black|white|slate|zinc|neutral|stone|orange|amber|lime|emerald|teal|cyan|sky|violet|fuchsia|rose)-(\d+)?\b/g, name: 'background' },
+        { pattern: /\b(?:block|inline-block|inline|flex|inline-flex|grid|inline-grid|hidden|contents|flow-root|list-item)\b/g, name: 'display' },
+        { pattern: /\btext-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)\b/g, name: 'font-size' },
+        { pattern: /\bfont-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)\b/g, name: 'font-weight' },
+        { pattern: /\bjustify-(start|end|center|between|around|evenly|stretch)\b/g, name: 'justify-content' },
+        { pattern: /\bitems-(start|end|center|baseline|stretch)\b/g, name: 'align-items' },
+        { pattern: /\bw-(\d+|\/\w+|full|screen|auto|min|max|fit)\b/g, name: 'width' },
+        { pattern: /\bh-(\d+|\/\w+|full|screen|auto|min|max|fit)\b/g, name: 'height' },
+    ];
+    const classNameRe = /className\s*=\s*["']([^"']+)["']/g;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let cm;
+        classNameRe.lastIndex = 0;
+        while ((cm = classNameRe.exec(line)) !== null) {
+            const classStr = cm[1];
+            for (const { pattern, name } of conflictGroups) {
+                const found = [];
+                pattern.lastIndex = 0;
+                let mm;
+                while ((mm = pattern.exec(classStr)) !== null)
+                    found.push(mm[0]);
+                if (found.length > 1) {
+                    conflicts.push({ line: i + 1, classes: found, reason: `Multiple ${name} classes: ${found.join(', ')}` });
+                }
+            }
+        }
+    }
+    return { file, conflicts, count: conflicts.length };
+}
+export function inspectClientBoundary(content, file) {
+    const lines = content.split('\n');
+    let directive = null;
+    const serverOnlyModules = ['server-only', 'next/headers', 'next-auth/server'];
+    const serverOnlyImports = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed === "'use client';" || trimmed === '"use client";' || trimmed === "'use client'" || trimmed === '"use client"') {
+            directive = 'use client';
+            break;
+        }
+        if (trimmed === "'use server';" || trimmed === '"use server";' || trimmed === "'use server'" || trimmed === '"use server"') {
+            directive = 'use server';
+            break;
+        }
+        break;
+    }
+    const importRe = /import\s+[\s\S]*?from\s+['"]([^'"]+)['"]/g;
+    let im;
+    while ((im = importRe.exec(content)) !== null) {
+        if (serverOnlyModules.some((mod) => im[1] === mod || im[1].startsWith(mod + '/')))
+            serverOnlyImports.push(im[1]);
+    }
+    return { file, directive, importsServerOnly: serverOnlyImports.length > 0, serverOnlyImports };
+}
+export function inspectErrorBoundary(content, file) {
+    const boundaryComponents = [];
+    const coveredRoutes = [];
+    const errorBoundaryRe = /(?:class\s+(\w*ErrorBoundary\w*)\s+extends|<(\w*ErrorBoundary\w*)|import\s+.*?(\w*ErrorBoundary\w*).*?from)/g;
+    let m;
+    while ((m = errorBoundaryRe.exec(content)) !== null) {
+        const name = m[1] || m[2] || m[3];
+        if (name && !boundaryComponents.includes(name))
+            boundaryComponents.push(name);
+    }
+    if (/(?:^|[\/\\])error\.[jt]sx?$/.test(file))
+        boundaryComponents.push('error.tsx (Next.js App Router)');
+    const wrappedRouteRe = /<(?:\w*ErrorBoundary\w*)[^>]*>[\s\S]*?<\/(?:\w*ErrorBoundary\w*)>/g;
+    let wr;
+    while ((wr = wrappedRouteRe.exec(content)) !== null) {
+        const routeMatch = /<(\w+)/.exec(wr[0].slice(wr[0].indexOf('>') + 1));
+        if (routeMatch && !coveredRoutes.includes(routeMatch[1]))
+            coveredRoutes.push(routeMatch[1]);
+    }
+    return { file, hasErrorBoundary: boundaryComponents.length > 0, boundaryComponents, coveredRoutes };
+}

package/dist/platform/tools/inspect/index.d.ts

@@ -0,0 +1,13 @@
+import type { Tool, ToolDefinition } from '../../types/tools.js';
+import { type InspectToolResult } from './shared.js';
+import type { FeatureFlagManager } from '../../runtime/feature-flags/index.js';
+export declare class InspectTool implements Tool {
+    private readonly featureFlags?;
+    private readonly projectRoot;
+    constructor(featureFlags?: (Pick<FeatureFlagManager, "isEnabled"> | null) | undefined, projectRoot?: string | null);
+    readonly definition: ToolDefinition;
+    private _withFingerprint;
+    execute(args: Record<string, unknown>): Promise<InspectToolResult>;
+    private _fingerprintResult;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/tools/inspect/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/inspect/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAKjE,OAAO,EAAmC,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEtF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE/E,qBAAa,WAAY,YAAW,IAAI;IAEpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW;gBADX,YAAY,CAAC,GAAE,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAAG,IAAI,aAAA,EAC3D,WAAW,GAAE,MAAM,GAAG,IAAW;IAGpD,QAAQ,CAAC,UAAU,EAAE,cAAc,CAYjC;IAEF,OAAO,CAAC,gBAAgB;IAelB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAsBxE,OAAO,CAAC,kBAAkB;CAU3B"}