@lensmcp/nx-plugin 1.0.0

package/generators/init/init.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGenerator = initGenerator;
+const devkit_1 = require("@nx/devkit");
+/** Workspace-wide config defaults, written into `nx.json#lensmcp`. */
+const DEFAULT_LENSMCP_CONFIG = {
+    schemaVersion: 1,
+    storage: 'memory',
+    transport: 'stdio',
+    retention: {
+        sessions: 5,
+        events: 5000,
+        screenshots: 50,
+        buildReports: 20,
+        visualFrames: 200,
+        heapSnapshots: 3,
+        tracesWithErrors: 20,
+        verifications: 10,
+    },
+    redaction: {
+        headers: ['authorization', 'cookie', 'set-cookie', 'x-api-key'],
+        paths: ['password', 'token', 'secret', 'apiKey', 'api_key'],
+    },
+    channels: {
+        blockingStatusChanged: { enabled: true, minSeverity: 'error' },
+        memoryLeakSuspected: { enabled: true, minSeverity: 'warning' },
+        bundleRegression: { enabled: true, minSeverity: 'warning' },
+        visualViolationBlocking: { enabled: true, minSeverity: 'error' },
+        verificationCompleted: { enabled: true, minSeverity: 'info' },
+    },
+    // Tunable detection thresholds — when each signal fires. Edit to taste;
+    // the server reads these at boot (see @lensmcp/core resolveThresholds).
+    thresholds: {
+        dbInLoop: 5,
+        nPlusOne: 3,
+        renderStorm: 5,
+        slowRouteMs: 500,
+        slowRenderMs: 16,
+    },
+};
+const LENSMCP_GITIGNORE_MARKER = '# LensMCP runtime artifacts (per-session storage)';
+const LENSMCP_GITIGNORE_ENTRY = '.lensmcp/';
+async function initGenerator(tree, rawOptions = {}) {
+    const options = {
+        skipFormat: rawOptions.skipFormat ?? false,
+        registerHostConfig: rawOptions.registerHostConfig ?? 'auto',
+    };
+    const steps = [];
+    // 1. Register the plugin + lensmcp config in nx.json (idempotent).
+    if (tree.exists('nx.json')) {
+        (0, devkit_1.updateJson)(tree, 'nx.json', (nx) => {
+            nx.plugins = Array.isArray(nx.plugins) ? nx.plugins : [];
+            const alreadyRegistered = nx.plugins.some((p) => {
+                if (typeof p === 'string')
+                    return p === '@lensmcp/nx-plugin';
+                if (p && typeof p === 'object' && 'plugin' in p) {
+                    return p.plugin === '@lensmcp/nx-plugin';
+                }
+                return false;
+            });
+            if (!alreadyRegistered) {
+                nx.plugins.push('@lensmcp/nx-plugin');
+                steps.push('nx.json: registered @lensmcp/nx-plugin');
+            }
+            const existing = (nx.lensmcp ?? {});
+            nx.lensmcp = mergeDeep(DEFAULT_LENSMCP_CONFIG, existing);
+            if (!('lensmcp' in nx) || Object.keys(existing).length === 0) {
+                steps.push('nx.json: added workspace-wide `lensmcp` config block');
+            }
+            return nx;
+        });
+    }
+    else {
+        throw new Error('No nx.json found at the workspace root. Are you in a Nx workspace?');
+    }
+    // 2. .gitignore — add `.lensmcp/` line (idempotent).
+    const gitignorePath = '.gitignore';
+    const existing = tree.exists(gitignorePath) ? tree.read(gitignorePath, 'utf-8') ?? '' : '';
+    if (!existing.split('\n').some((l) => l.trim() === LENSMCP_GITIGNORE_ENTRY)) {
+        const trailingNewline = existing.endsWith('\n') ? '' : '\n';
+        tree.write(gitignorePath, `${existing}${trailingNewline}\n${LENSMCP_GITIGNORE_MARKER}\n${LENSMCP_GITIGNORE_ENTRY}\n`);
+        steps.push(`${gitignorePath}: added \`${LENSMCP_GITIGNORE_ENTRY}\``);
+    }
+    // 3. Reserve the .lensmcp/ directory with a sentinel file.
+    const keepPath = (0, devkit_1.joinPathFragments)('.lensmcp', '.keep');
+    if (!tree.exists(keepPath)) {
+        tree.write(keepPath, '');
+        steps.push(`${keepPath}: created`);
+    }
+    // 4. Write an install trail so subsequent re-runs can read what was
+    //    done and (in future generators) un-install precisely.
+    const trailPath = (0, devkit_1.joinPathFragments)('.lensmcp', 'install-trail.json');
+    const existingTrail = tree.exists(trailPath)
+        ? JSON.parse(tree.read(trailPath, 'utf-8') ?? '{}')
+        : undefined;
+    const trail = existingTrail ?? {
+        schemaVersion: 1,
+        installedAt: new Date().toISOString(),
+        steps: [],
+    };
+    trail.steps.push(...steps);
+    tree.write(trailPath, JSON.stringify(trail, null, 2) + '\n');
+    // 5. Register the LensMCP MCP server in the workspace `.mcp.json` so any
+    //    coding agent (Claude Code, Cursor, …) opening this project gets the
+    //    lens automatically. Workspace-local edits happen here, in the Nx
+    //    tree (idempotent). Global agent configs (~/.claude, ~/.cursor) are
+    //    only touched by `lensmcp` when `registerHostConfig: 'always'`,
+    //    since those live outside the workspace.
+    if (options.registerHostConfig !== 'never') {
+        registerWorkspaceMcpConfig(tree, steps);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+/** The stdio MCP server entry a host agent uses to launch LensMCP. */
+const LENSMCP_MCP_SERVER_ENTRY = {
+    command: 'npx',
+    args: ['-y', 'lensmcp', 'mcp'],
+};
+/**
+ * Ensure `<workspace>/.mcp.json` has a `lensmcp` MCP server entry.
+ * Idempotent: creates the file if absent, merges into existing
+ * `mcpServers`, and never clobbers a `lensmcp` entry the user already
+ * customised.
+ */
+function registerWorkspaceMcpConfig(tree, steps) {
+    const path = '.mcp.json';
+    let config = {};
+    if (tree.exists(path)) {
+        try {
+            config = JSON.parse(tree.read(path, 'utf-8') ?? '{}');
+        }
+        catch {
+            config = {};
+        }
+    }
+    if (!config || typeof config !== 'object')
+        config = {};
+    if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+        config.mcpServers = {};
+    }
+    if (config.mcpServers['lensmcp'])
+        return; // already registered — leave it
+    config.mcpServers['lensmcp'] = { ...LENSMCP_MCP_SERVER_ENTRY };
+    tree.write(path, JSON.stringify(config, null, 2) + '\n');
+    steps.push('.mcp.json: registered lensmcp MCP server (stdio)');
+}
+exports.default = initGenerator;
+// -------- helpers --------
+function mergeDeep(defaults, overrides) {
+    const out = { ...defaults };
+    for (const [key, value] of Object.entries(overrides)) {
+        if (value !== null &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            out[key] !== null &&
+            typeof out[key] === 'object' &&
+            !Array.isArray(out[key])) {
+            out[key] = mergeDeep(out[key], value);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}

package/generators/init/schema.d.ts

@@ -0,0 +1,4 @@
+export interface InitGeneratorSchema {
+  skipFormat?: boolean;
+  registerHostConfig?: 'auto' | 'never' | 'always';
+}

package/generators/init/schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "LensmcpInit",
+  "title": "Install LensMCP",
+  "description": "Wires LensMCP into a host Nx workspace: registers the plugin in nx.json, adds the workspace-wide `lensmcp` config block, patches .gitignore, and prepares the .lensmcp runtime directory.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "skipFormat": {
+      "type": "boolean",
+      "default": false,
+      "description": "Skip Prettier formatting of touched files."
+    },
+    "registerHostConfig": {
+      "type": "string",
+      "enum": ["auto", "never", "always"],
+      "default": "auto",
+      "description": "Whether to also append a `lensmcp` entry to the host agent's MCP client config (~/.claude/mcp.json, ~/.cursor/mcp.json, <workspace>/.mcp.json). `auto` patches existing files only; never modifies anything outside the workspace by default."
+    }
+  },
+  "required": []
+}

package/generators/setup-nest/schema.d.ts

@@ -0,0 +1,4 @@
+export interface SetupNestGeneratorSchema {
+  project: string;
+  skipFormat?: boolean;
+}

package/generators/setup-nest/schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "LensmcpSetupNest",
+  "title": "setup-nest",
+  "description": "Wire LensMCP into a NestJS project: add LensmcpModule.forRoot() to AppModule + add agent-dev target.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "Target Nx project (must have an app.module.ts and main.ts).",
+      "x-prompt": "Which NestJS project?",
+      "x-priority": "important"
+    },
+    "skipFormat": { "type": "boolean", "default": false }
+  },
+  "required": ["project"]
+}

package/generators/setup-nest/setup-nest.d.ts

@@ -0,0 +1,41 @@
+import { type Tree } from '@nx/devkit';
+import type { SetupNestGeneratorSchema } from './schema';
+/**
+ * Wires LensMCP into a host NestJS project with **no app-code edits**.
+ * Idempotent.
+ *
+ * Zero-config strategy (Phase 8): rewrite the bootstrap in `src/main.ts`
+ * so `NestFactory.create(AppModule, opts)` becomes
+ * `createLensmcpNestApp(AppModule, { projectName: '<project>', nestOptions: opts })`.
+ * `createLensmcpNestApp` wires `LensmcpModule` + the provider tracker +
+ * auto-instruments every provider's methods under the hood, so the app
+ * module and the providers stay untouched.
+ *
+ * 1. Find the project's `src/main.ts` (the conventional Nest entry).
+ * 2. Replace the `NestFactory.create(...)` call with
+ *    `createLensmcpNestApp(...)`, threading the original 2nd arg through
+ *    as `nestOptions` and adding the `@lensmcp/nest-instrumentation`
+ *    import (dropping the now-unused `NestFactory` import when nothing
+ *    else uses it). String/AST-lite — if the file doesn't follow the
+ *    canonical shape we print a precise hint and exit non-zero.
+ * 3. Add an `agent-dev` Nx target.
+ */
+export declare function setupNestGenerator(tree: Tree, rawOptions: SetupNestGeneratorSchema): Promise<void>;
+export default setupNestGenerator;
+export declare function findAppModule(tree: Tree, root: string): string | undefined;
+/**
+ * Rewrite a Nest `main.ts` bootstrap to the zero-config form. Returns the
+ * original string unchanged when already converted (idempotent), `null`
+ * when no `NestFactory.create(...)` call is present (caller decides), or
+ * the rewritten source otherwise.
+ */
+export declare function patchMainBootstrap(src: string, projectName: string): string | null;
+/**
+ * Legacy module-style wiring. Adds `LensmcpModule.forRoot(...)` into the
+ * `@Module({ imports: [...] })` array. Superseded by the `main.ts`
+ * bootstrap rewrite ({@link patchMainBootstrap}) but kept for hosts whose
+ * entry file doesn't follow the canonical `NestFactory.create` shape.
+ * Idempotent. Returns `null` when no `@Module` imports array is found.
+ */
+export declare function patchAppModule(src: string, projectName: string): string | null;
+//# sourceMappingURL=setup-nest.d.ts.map

package/generators/setup-nest/setup-nest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-nest.d.ts","sourceRoot":"","sources":["../../../src/generators/setup-nest/setup-nest.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,IAAI,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAOzD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,wBAAwB,GACnC,OAAO,CAAC,IAAI,CAAC,CA+Cf;AAED,eAAe,kBAAkB,CAAC;AAYlC,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM1E;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,IAAI,CA0Bf;AAgID;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiC9E"}

package/generators/setup-nest/setup-nest.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupNestGenerator = setupNestGenerator;
+exports.findAppModule = findAppModule;
+exports.patchMainBootstrap = patchMainBootstrap;
+exports.patchAppModule = patchAppModule;
+const devkit_1 = require("@nx/devkit");
+const BOOTSTRAP_IMPORT = `import { createLensmcpNestApp } from '@lensmcp/nest-instrumentation';`;
+// Legacy module-style wiring, kept for the manual-fallback hint.
+const IMPORT_LINE = `import { LensmcpModule } from '@lensmcp/nest-instrumentation';`;
+const MODULE_CALL = "LensmcpModule.forRoot({ projectName: '__PROJECT__' })";
+/**
+ * Wires LensMCP into a host NestJS project with **no app-code edits**.
+ * Idempotent.
+ *
+ * Zero-config strategy (Phase 8): rewrite the bootstrap in `src/main.ts`
+ * so `NestFactory.create(AppModule, opts)` becomes
+ * `createLensmcpNestApp(AppModule, { projectName: '<project>', nestOptions: opts })`.
+ * `createLensmcpNestApp` wires `LensmcpModule` + the provider tracker +
+ * auto-instruments every provider's methods under the hood, so the app
+ * module and the providers stay untouched.
+ *
+ * 1. Find the project's `src/main.ts` (the conventional Nest entry).
+ * 2. Replace the `NestFactory.create(...)` call with
+ *    `createLensmcpNestApp(...)`, threading the original 2nd arg through
+ *    as `nestOptions` and adding the `@lensmcp/nest-instrumentation`
+ *    import (dropping the now-unused `NestFactory` import when nothing
+ *    else uses it). String/AST-lite — if the file doesn't follow the
+ *    canonical shape we print a precise hint and exit non-zero.
+ * 3. Add an `agent-dev` Nx target.
+ */
+async function setupNestGenerator(tree, rawOptions) {
+    const options = {
+        project: rawOptions.project,
+        skipFormat: rawOptions.skipFormat ?? false,
+    };
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const mainPath = findMain(tree, project.root);
+    if (!mainPath) {
+        throw new Error(`setup-nest: no main.ts found under ${project.root}/src.`);
+    }
+    const original = tree.read(mainPath, 'utf-8') ?? '';
+    const patched = patchMainBootstrap(original, options.project);
+    if (patched === null) {
+        throw new Error(`setup-nest: could not safely patch ${mainPath}.\n` +
+            `Expected a \`NestFactory.create(AppModule)\` bootstrap call. ` +
+            `Edit manually: replace it with \`createLensmcpNestApp(AppModule, ` +
+            `{ projectName: '${options.project}' })\` and import it from ` +
+            `'@lensmcp/nest-instrumentation'.\n` +
+            `(Or use the module form: add \`${IMPORT_LINE}\` and push ` +
+            `${MODULE_CALL.replace('__PROJECT__', options.project)} into the ` +
+            `@Module imports array.)`);
+    }
+    if (patched !== original) {
+        tree.write(mainPath, patched);
+    }
+    const targets = { ...(project.targets ?? {}) };
+    if (!targets['agent-dev']) {
+        targets['agent-dev'] = {
+            executor: '@lensmcp/nx-plugin:agent-dev',
+            options: {
+                kind: 'nestjs',
+            },
+        };
+        project.targets = targets;
+        (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = setupNestGenerator;
+// ---------- helpers ----------
+function findMain(tree, root) {
+    for (const name of ['src/main.ts', 'main.ts', 'src/index.ts']) {
+        const p = (0, devkit_1.joinPathFragments)(root, name);
+        if (tree.exists(p))
+            return p;
+    }
+    return undefined;
+}
+function findAppModule(tree, root) {
+    for (const name of ['src/app.module.ts', 'app.module.ts']) {
+        const p = (0, devkit_1.joinPathFragments)(root, name);
+        if (tree.exists(p))
+            return p;
+    }
+    return undefined;
+}
+const CREATE_CALL_RE = /NestFactory\s*\.\s*create\s*(?:<[\s\S]*?>)?\s*\(/;
+/**
+ * Rewrite a Nest `main.ts` bootstrap to the zero-config form. Returns the
+ * original string unchanged when already converted (idempotent), `null`
+ * when no `NestFactory.create(...)` call is present (caller decides), or
+ * the rewritten source otherwise.
+ */
+function patchMainBootstrap(src, projectName) {
+    // Already zero-config — nothing to do.
+    if (/createLensmcpNestApp\s*\(/.test(src))
+        return src;
+    const m = CREATE_CALL_RE.exec(src);
+    if (!m)
+        return null;
+    const openParen = m.index + m[0].length - 1; // index of the '('
+    const closeParen = matchingParen(src, openParen);
+    if (closeParen === -1)
+        return null;
+    const argsStr = src.slice(openParen + 1, closeParen);
+    const { moduleArg, restArg } = splitTopLevelArgs(argsStr);
+    if (!moduleArg.trim())
+        return null;
+    const proj = projectName.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    const rest = restArg.trim();
+    const optsObject = rest
+        ? `{ projectName: '${proj}', nestOptions: ${rest} }`
+        : `{ projectName: '${proj}' }`;
+    const replacement = `createLensmcpNestApp(${moduleArg.trim()}, ${optsObject})`;
+    let out = src.slice(0, m.index) + replacement + src.slice(closeParen + 1);
+    out = addBootstrapImport(out);
+    out = dropUnusedNestFactoryImport(out);
+    return out;
+}
+/** Insert the `createLensmcpNestApp` import after the last import, unless
+ *  the symbol is already imported from `@lensmcp/nest-instrumentation`. */
+function addBootstrapImport(src) {
+    const already = /createLensmcpNestApp[\s\S]*?from\s*['"]@lensmcp\/nest-instrumentation['"]/.test(src);
+    if (already)
+        return src;
+    const importLines = [...src.matchAll(/^\s*import .+;?\s*$/gm)];
+    const last = importLines.length ? importLines[importLines.length - 1] : null;
+    if (last && last.index !== undefined) {
+        const at = last.index + last[0].length;
+        return src.slice(0, at) + `\n${BOOTSTRAP_IMPORT}` + src.slice(at);
+    }
+    return `${BOOTSTRAP_IMPORT}\n${src}`;
+}
+/** Strip `NestFactory` from its `@nestjs/core` named import when nothing
+ *  in the file references `NestFactory` any more. */
+function dropUnusedNestFactoryImport(src) {
+    // Reference check excludes the import statement itself.
+    if (/\bNestFactory\b/.test(stripNestFactoryImportSpan(src).rest))
+        return src;
+    const { match } = stripNestFactoryImportSpan(src);
+    if (!match)
+        return src;
+    const names = match.names.filter((n) => n !== 'NestFactory');
+    if (names.length === 0) {
+        // Remove the whole import statement (and its trailing newline).
+        return src.slice(0, match.start) + src.slice(match.end).replace(/^\n/, '');
+    }
+    const rebuilt = `import { ${names.join(', ')} } from '@nestjs/core';`;
+    return src.slice(0, match.start) + rebuilt + src.slice(match.end);
+}
+/** Locate the `@nestjs/core` named import; return its span + names and the
+ *  source with that span removed (so the caller can test references that
+ *  live *outside* the import). */
+function stripNestFactoryImportSpan(src) {
+    const re = /import\s*\{([^}]*)\}\s*from\s*['"]@nestjs\/core['"];?/;
+    const m = re.exec(src);
+    if (!m)
+        return { match: null, rest: src };
+    const names = m[1]
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const start = m.index;
+    const end = m.index + m[0].length;
+    const rest = src.slice(0, start) + src.slice(end);
+    return { match: { start, end, names }, rest };
+}
+/** Index of the `)` matching the `(` at `openIdx`, skipping strings,
+ *  template literals and comments. Returns -1 if unbalanced. */
+function matchingParen(src, openIdx) {
+    let depth = 0;
+    for (let i = openIdx; i < src.length; i++) {
+        const skip = skipNonCode(src, i);
+        if (skip > i) {
+            i = skip - 1;
+            continue;
+        }
+        const ch = src[i];
+        if (ch === '(')
+            depth++;
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/** Split call arguments at the first top-level comma. */
+function splitTopLevelArgs(argsStr) {
+    let depth = 0;
+    for (let i = 0; i < argsStr.length; i++) {
+        const skip = skipNonCode(argsStr, i);
+        if (skip > i) {
+            i = skip - 1;
+            continue;
+        }
+        const ch = argsStr[i];
+        if (ch === '(' || ch === '[' || ch === '{')
+            depth++;
+        else if (ch === ')' || ch === ']' || ch === '}')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            return {
+                moduleArg: argsStr.slice(0, i),
+                restArg: argsStr.slice(i + 1),
+            };
+        }
+    }
+    return { moduleArg: argsStr, restArg: '' };
+}
+/** If position `i` starts a string/template/comment, return the index just
+ *  past it; otherwise return `i`. */
+function skipNonCode(src, i) {
+    const ch = src[i];
+    if (ch === '"' || ch === "'" || ch === '`') {
+        for (let j = i + 1; j < src.length; j++) {
+            if (src[j] === '\\') {
+                j++;
+                continue;
+            }
+            if (src[j] === ch)
+                return j + 1;
+        }
+        return src.length;
+    }
+    if (ch === '/' && src[i + 1] === '/') {
+        const nl = src.indexOf('\n', i);
+        return nl === -1 ? src.length : nl;
+    }
+    if (ch === '/' && src[i + 1] === '*') {
+        const end = src.indexOf('*/', i + 2);
+        return end === -1 ? src.length : end + 2;
+    }
+    return i;
+}
+/**
+ * Legacy module-style wiring. Adds `LensmcpModule.forRoot(...)` into the
+ * `@Module({ imports: [...] })` array. Superseded by the `main.ts`
+ * bootstrap rewrite ({@link patchMainBootstrap}) but kept for hosts whose
+ * entry file doesn't follow the canonical `NestFactory.create` shape.
+ * Idempotent. Returns `null` when no `@Module` imports array is found.
+ */
+function patchAppModule(src, projectName) {
+    const hasImport = src.includes("from '@lensmcp/nest-instrumentation'") ||
+        src.includes('from "@lensmcp/nest-instrumentation"');
+    const hasModuleCall = /LensmcpModule\s*\.\s*forRoot\s*\(/.test(src);
+    if (hasImport && hasModuleCall)
+        return src;
+    const importsAnchor = src.indexOf('imports:');
+    if (importsAnchor === -1)
+        return null;
+    const bracketStart = src.indexOf('[', importsAnchor);
+    if (bracketStart === -1)
+        return null;
+    let withImport = src;
+    if (!hasImport) {
+        const importLines = [...src.matchAll(/^\s*import .+;?\s*$/gm)];
+        const lastImport = importLines.length > 0 ? importLines[importLines.length - 1] : null;
+        if (lastImport && lastImport.index !== undefined) {
+            const insertAt = lastImport.index + lastImport[0].length;
+            withImport = src.slice(0, insertAt) + `\n${IMPORT_LINE}` + src.slice(insertAt);
+        }
+        else {
+            withImport = `${IMPORT_LINE}\n` + src;
+        }
+    }
+    if (hasModuleCall)
+        return withImport;
+    const adjBracket = withImport.indexOf('[', withImport.indexOf('imports:'));
+    const before = withImport.slice(0, adjBracket + 1);
+    const after = withImport.slice(adjBracket + 1);
+    const trimmedAfter = after.replace(/^\s*/, '');
+    const startsClosed = trimmedAfter.startsWith(']');
+    const separator = startsClosed ? '' : ', ';
+    const call = MODULE_CALL.replace('__PROJECT__', projectName);
+    return `${before}${call}${separator}${after}`;
+}

package/generators/setup-vite/schema.d.ts

@@ -0,0 +1,4 @@
+export interface SetupViteGeneratorSchema {
+  project: string;
+  skipFormat?: boolean;
+}

package/generators/setup-vite/schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "LensmcpSetupVite",
+  "title": "setup-vite",
+  "description": "Wire LensMCP into a Vite project: add @lensmcp/vite-plugin to vite.config.ts, add the agent-dev Nx target.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "Target Nx project (must already exist and have a vite.config.ts).",
+      "x-prompt": "Which Vite project?",
+      "x-priority": "important"
+    },
+    "skipFormat": { "type": "boolean", "default": false }
+  },
+  "required": ["project"]
+}

package/generators/setup-vite/setup-vite.d.ts

@@ -0,0 +1,31 @@
+import { type Tree } from '@nx/devkit';
+import type { SetupViteGeneratorSchema } from './schema';
+/**
+ * Wires LensMCP into a host Vite project. Idempotent on every step.
+ *
+ * 1. Locate the project's vite.config.{ts,mts,js,mjs,cts,cjs}.
+ * 2. Add `import { lensmcpVitePlugin } from '@lensmcp/vite-plugin'`
+ *    near the top (after the last existing import).
+ * 3. Insert `lensmcpVitePlugin({ enabled: mode !== 'production' })`
+ *    into the `plugins` array if not already present. We do *not*
+ *    AST-edit — we use string heuristics on the standard
+ *    `defineConfig({ plugins: [...] })` shape. If the file is too
+ *    custom for the heuristics, we print a diff hint and bail.
+ * 4. Add Nx targets: agent-dev, agent-build, agent-verify.
+ */
+export declare function setupViteGenerator(tree: Tree, rawOptions: SetupViteGeneratorSchema): Promise<void>;
+export default setupViteGenerator;
+/**
+ * String-heuristic patch:
+ *
+ * 1. If the file already imports `@lensmcp/vite-plugin` and mentions
+ *    `lensmcpVitePlugin(` in the plugins array, return unchanged.
+ * 2. Otherwise insert the import near the top (after the last
+ *    `import …` line) and add the plugin call to the plugins array
+ *    declared by `plugins: [` (first occurrence).
+ *
+ * If neither anchor is found, return `null` so the generator can ask
+ * the user to patch manually.
+ */
+export declare function patchViteConfig(src: string): string | null;
+//# sourceMappingURL=setup-vite.d.ts.map

package/generators/setup-vite/setup-vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-vite.d.ts","sourceRoot":"","sources":["../../../src/generators/setup-vite/setup-vite.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,IAAI,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAIzD;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,wBAAwB,GACnC,OAAO,CAAC,IAAI,CAAC,CA8Cf;AAED,eAAe,kBAAkB,CAAC;AAoBlC;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAoC1D"}