@ng-annotate/angular 0.3.5 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ng-annotate/angular",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "schematics": "./schematics/collection.json",
   "description": "Angular library for ng-annotate-mcp — browser overlay for annotating components and routing instructions to an AI agent",
   "keywords": [

package/schematics/ng-add/index.js

@@ -1,8 +1,68 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const schematics_1 = require("@angular-devkit/schematics");
 const tasks_1 = require("@angular-devkit/schematics/tasks");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Insert `newImport` on the line after the last import statement (handles multi-line imports and blank lines between groups). */
+function insertAfterLastImport(content, newImport) {
+    const lines = content.split('\n');
+    let lastImportLine = -1;
+    let inImport = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (/^import\s/.test(lines[i]))
+            inImport = true;
+        if (inImport) {
+            lastImportLine = i;
+            if (lines[i].includes(';'))
+                inImport = false;
+        }
+    }
+    if (lastImportLine < 0)
+        return newImport + '\n' + content;
+    lines.splice(lastImportLine + 1, 0, newImport);
+    return lines.join('\n');
+}
+/** Insert `newProvider` as the first item in the `providers: [...]` array, preserving indentation style. */
+function insertIntoProviders(content, newProvider) {
+    return content.replace(/^(\s*)providers\s*:\s*\[/m, (match, indent) => {
+        return `${indent}providers: [\n${indent}  ${newProvider},`;
+    });
+}
 const MIN_ANGULAR_MAJOR = 21;
 function checkAngularVersion() {
     return (tree) => {
@@ -34,9 +94,7 @@ function addVitePlugin() {
             context.logger.info('@ng-annotate/vite-plugin vite plugin already present, skipping.');
             return;
         }
-        // Insert import after the last existing import line
-        content = content.replace(/(^import .+$(\r?\n)?)+/m, (match) => match + "import { ngAnnotateMcp } from '@ng-annotate/vite-plugin';\n");
-        // Insert spread into plugins array (handles `plugins: [` or `plugins:[`)
+        content = insertAfterLastImport(content, "import { ngAnnotateMcp } from '@ng-annotate/vite-plugin';");
         content = content.replace(/plugins\s*:\s*\[/, 'plugins: [...ngAnnotateMcp(), ');
         tree.overwrite(viteConfigPath, content);
         context.logger.info(`✅ Added ngAnnotateMcp() to ${viteConfigPath}`);
@@ -61,20 +119,49 @@ function addProviders() {
             context.logger.info('provideNgAnnotate already present, skipping.');
             return;
         }
-        // Insert import after the last existing import line
-        content = content.replace(/(^import .+$(\r?\n)?)+/m, (match) => match + "import { provideNgAnnotate } from '@ng-annotate/angular';\n");
-        // Insert into providers array
-        content = content.replace(/providers\s*:\s*\[/, 'providers: [\n    provideNgAnnotate(),');
+        content = insertAfterLastImport(content, "import { provideNgAnnotate } from '@ng-annotate/angular';");
+        content = insertIntoProviders(content, 'provideNgAnnotate()');
         tree.overwrite(appConfigPath, content);
         context.logger.info(`✅ Added provideNgAnnotate() to ${appConfigPath}`);
     };
 }
+/** Walk up from startDir until we find a .git folder; returns that directory or null. */
+function findGitRoot(startDir) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(dir, '.git')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Write a config file outside the schematic Tree (e.g. to a parent git root).
+ * Uses fs directly — intentionally bypasses Tree so it works for out-of-project paths.
+ */
+function writeOutsideTree(absPath, content, context) {
+    const dir = path.dirname(absPath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    if (fs.existsSync(absPath)) {
+        context.logger.info(`${path.basename(absPath)} already exists at workspace root, skipping.`);
+        return;
+    }
+    fs.writeFileSync(absPath, content, 'utf-8');
+    context.logger.info(`✅ Created ${path.basename(absPath)} at workspace root (${dir})`);
+}
 function addMcpConfig(options) {
     return (tree, context) => {
-        const projectRoot = process.cwd().replace(/\\/g, '/');
-        const env = { NG_ANNOTATE_PROJECT_ROOT: projectRoot };
+        const projectRoot = process.cwd();
+        const env = { NG_ANNOTATE_PROJECT_ROOT: projectRoot.replace(/\\/g, '/') };
         const isWindows = process.platform === 'win32';
         const { aiTool } = options;
+        // Detect monorepo: if git root is a parent of the Angular project, VS Code is likely
+        // opened there — write configs to both the project folder and the git root.
+        const gitRoot = findGitRoot(projectRoot);
+        const isSubproject = gitRoot !== null && path.resolve(gitRoot) !== path.resolve(projectRoot);
         if (aiTool === 'other') {
             const claudeConfig = JSON.stringify({
                 mcpServers: {
@@ -104,41 +191,47 @@ function addMcpConfig(options) {
         }
         // .mcp.json — Claude Code (needs cmd /c on Windows to invoke npx.cmd)
         if (aiTool === 'claude-code' || aiTool === 'both') {
+            const mcpConfig = JSON.stringify({
+                mcpServers: {
+                    'ng-annotate': isWindows
+                        ? { command: 'cmd', args: ['/c', 'npx', '-y', '@ng-annotate/mcp-server'], env }
+                        : { command: 'npx', args: ['-y', '@ng-annotate/mcp-server'], env },
+                },
+            }, null, 2) + '\n';
             if (!tree.exists('.mcp.json')) {
-                const mcpConfig = {
-                    mcpServers: {
-                        'ng-annotate': isWindows
-                            ? { command: 'cmd', args: ['/c', 'npx', '-y', '@ng-annotate/mcp-server'], env }
-                            : { command: 'npx', args: ['-y', '@ng-annotate/mcp-server'], env },
-                    },
-                };
-                tree.create('.mcp.json', JSON.stringify(mcpConfig, null, 2) + '\n');
+                tree.create('.mcp.json', mcpConfig);
                 context.logger.info('✅ Created .mcp.json');
             }
             else {
                 context.logger.info('.mcp.json already exists, skipping.');
             }
+            if (isSubproject) {
+                writeOutsideTree(path.join(gitRoot, '.mcp.json'), mcpConfig, context);
+            }
         }
         // .vscode/mcp.json — VS Code Copilot
         if (aiTool === 'vscode' || aiTool === 'both') {
+            const vscodeMcpConfig = JSON.stringify({
+                servers: {
+                    'ng-annotate': {
+                        type: 'stdio',
+                        command: 'npx',
+                        args: ['-y', '@ng-annotate/mcp-server'],
+                        env,
+                    },
+                },
+            }, null, 2) + '\n';
             const vscodeMcpPath = '.vscode/mcp.json';
             if (!tree.exists(vscodeMcpPath)) {
-                const vscodeMcpConfig = {
-                    servers: {
-                        'ng-annotate': {
-                            type: 'stdio',
-                            command: 'npx',
-                            args: ['-y', '@ng-annotate/mcp-server'],
-                            env,
-                        },
-                    },
-                };
-                tree.create(vscodeMcpPath, JSON.stringify(vscodeMcpConfig, null, 2) + '\n');
+                tree.create(vscodeMcpPath, vscodeMcpConfig);
                 context.logger.info('✅ Created .vscode/mcp.json');
             }
             else {
                 context.logger.info('.vscode/mcp.json already exists, skipping.');
             }
+            if (isSubproject) {
+                writeOutsideTree(path.join(gitRoot, '.vscode', 'mcp.json'), vscodeMcpConfig, context);
+            }
         }
     };
 }

package/schematics/ng-add/index.ts

@@ -1,5 +1,33 @@
 import { Rule, SchematicContext, Tree, chain, SchematicsException } from '@angular-devkit/schematics';
 import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/** Insert `newImport` on the line after the last import statement (handles multi-line imports and blank lines between groups). */
+function insertAfterLastImport(content: string, newImport: string): string {
+  const lines = content.split('\n');
+  let lastImportLine = -1;
+  let inImport = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (/^import\s/.test(lines[i])) inImport = true;
+    if (inImport) {
+      lastImportLine = i;
+      if (lines[i].includes(';')) inImport = false;
+    }
+  }
+
+  if (lastImportLine < 0) return newImport + '\n' + content;
+  lines.splice(lastImportLine + 1, 0, newImport);
+  return lines.join('\n');
+}
+
+/** Insert `newProvider` as the first item in the `providers: [...]` array, preserving indentation style. */
+function insertIntoProviders(content: string, newProvider: string): string {
+  return content.replace(/^(\s*)providers\s*:\s*\[/m, (match, indent) => {
+    return `${indent}providers: [\n${indent}  ${newProvider},`;
+  });
+}
 
 interface Options {
   aiTool: 'claude-code' | 'vscode' | 'both' | 'other';
@@ -49,13 +77,7 @@ function addVitePlugin(): Rule {
       return;
     }
 
-    // Insert import after the last existing import line
-    content = content.replace(
-      /(^import .+$(\r?\n)?)+/m,
-      (match) => match + "import { ngAnnotateMcp } from '@ng-annotate/vite-plugin';\n",
-    );
-
-    // Insert spread into plugins array (handles `plugins: [` or `plugins:[`)
+    content = insertAfterLastImport(content, "import { ngAnnotateMcp } from '@ng-annotate/vite-plugin';");
     content = content.replace(/plugins\s*:\s*\[/, 'plugins: [...ngAnnotateMcp(), ');
 
     tree.overwrite(viteConfigPath, content);
@@ -88,27 +110,53 @@ function addProviders(): Rule {
       return;
     }
 
-    // Insert import after the last existing import line
-    content = content.replace(
-      /(^import .+$(\r?\n)?)+/m,
-      (match) => match + "import { provideNgAnnotate } from '@ng-annotate/angular';\n",
-    );
-
-    // Insert into providers array
-    content = content.replace(/providers\s*:\s*\[/, 'providers: [\n    provideNgAnnotate(),');
+    content = insertAfterLastImport(content, "import { provideNgAnnotate } from '@ng-annotate/angular';");
+    content = insertIntoProviders(content, 'provideNgAnnotate()');
 
     tree.overwrite(appConfigPath, content);
     context.logger.info(`✅ Added provideNgAnnotate() to ${appConfigPath}`);
   };
 }
 
+/** Walk up from startDir until we find a .git folder; returns that directory or null. */
+function findGitRoot(startDir: string): string | null {
+  let dir = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, '.git'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * Write a config file outside the schematic Tree (e.g. to a parent git root).
+ * Uses fs directly — intentionally bypasses Tree so it works for out-of-project paths.
+ */
+function writeOutsideTree(absPath: string, content: string, context: SchematicContext): void {
+  const dir = path.dirname(absPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  if (fs.existsSync(absPath)) {
+    context.logger.info(`${path.basename(absPath)} already exists at workspace root, skipping.`);
+    return;
+  }
+  fs.writeFileSync(absPath, content, 'utf-8');
+  context.logger.info(`✅ Created ${path.basename(absPath)} at workspace root (${dir})`);
+}
+
 function addMcpConfig(options: Options): Rule {
   return (tree: Tree, context: SchematicContext) => {
-    const projectRoot = process.cwd().replace(/\\/g, '/');
-    const env = { NG_ANNOTATE_PROJECT_ROOT: projectRoot };
+    const projectRoot = process.cwd();
+    const env = { NG_ANNOTATE_PROJECT_ROOT: projectRoot.replace(/\\/g, '/') };
     const isWindows = process.platform === 'win32';
     const { aiTool } = options;
 
+    // Detect monorepo: if git root is a parent of the Angular project, VS Code is likely
+    // opened there — write configs to both the project folder and the git root.
+    const gitRoot = findGitRoot(projectRoot);
+    const isSubproject =
+      gitRoot !== null && path.resolve(gitRoot) !== path.resolve(projectRoot);
+
     if (aiTool === 'other') {
       const claudeConfig = JSON.stringify(
         {
@@ -149,40 +197,60 @@ function addMcpConfig(options: Options): Rule {
 
     // .mcp.json — Claude Code (needs cmd /c on Windows to invoke npx.cmd)
     if (aiTool === 'claude-code' || aiTool === 'both') {
-      if (!tree.exists('.mcp.json')) {
-        const mcpConfig = {
-          mcpServers: {
-            'ng-annotate': isWindows
-              ? { command: 'cmd', args: ['/c', 'npx', '-y', '@ng-annotate/mcp-server'], env }
-              : { command: 'npx', args: ['-y', '@ng-annotate/mcp-server'], env },
+      const mcpConfig =
+        JSON.stringify(
+          {
+            mcpServers: {
+              'ng-annotate': isWindows
+                ? { command: 'cmd', args: ['/c', 'npx', '-y', '@ng-annotate/mcp-server'], env }
+                : { command: 'npx', args: ['-y', '@ng-annotate/mcp-server'], env },
+            },
           },
-        };
-        tree.create('.mcp.json', JSON.stringify(mcpConfig, null, 2) + '\n');
+          null,
+          2,
+        ) + '\n';
+
+      if (!tree.exists('.mcp.json')) {
+        tree.create('.mcp.json', mcpConfig);
         context.logger.info('✅ Created .mcp.json');
       } else {
         context.logger.info('.mcp.json already exists, skipping.');
       }
+
+      if (isSubproject) {
+        writeOutsideTree(path.join(gitRoot!, '.mcp.json'), mcpConfig, context);
+      }
     }
 
     // .vscode/mcp.json — VS Code Copilot
     if (aiTool === 'vscode' || aiTool === 'both') {
-      const vscodeMcpPath = '.vscode/mcp.json';
-      if (!tree.exists(vscodeMcpPath)) {
-        const vscodeMcpConfig = {
-          servers: {
-            'ng-annotate': {
-              type: 'stdio',
-              command: 'npx',
-              args: ['-y', '@ng-annotate/mcp-server'],
-              env,
+      const vscodeMcpConfig =
+        JSON.stringify(
+          {
+            servers: {
+              'ng-annotate': {
+                type: 'stdio',
+                command: 'npx',
+                args: ['-y', '@ng-annotate/mcp-server'],
+                env,
+              },
             },
           },
-        };
-        tree.create(vscodeMcpPath, JSON.stringify(vscodeMcpConfig, null, 2) + '\n');
+          null,
+          2,
+        ) + '\n';
+
+      const vscodeMcpPath = '.vscode/mcp.json';
+      if (!tree.exists(vscodeMcpPath)) {
+        tree.create(vscodeMcpPath, vscodeMcpConfig);
         context.logger.info('✅ Created .vscode/mcp.json');
       } else {
         context.logger.info('.vscode/mcp.json already exists, skipping.');
       }
+
+      if (isSubproject) {
+        writeOutsideTree(path.join(gitRoot!, '.vscode', 'mcp.json'), vscodeMcpConfig, context);
+      }
     }
   };
 }