codebase-context 1.2.1 → 1.5.0

package/dist/analyzers/angular/index.js

@@ -3,22 +3,16 @@
  * Understands components, services, directives, pipes, modules, guards, interceptors, etc.
  * Detects state management patterns, architectural layers, and Angular-specific patterns
  */
-import { promises as fs } from "fs";
-import path from "path";
-import { parse } from "@typescript-eslint/typescript-estree";
-import { createChunksFromCode } from "../../utils/chunking.js";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { promises as fs } from 'fs';
+import path from 'path';
+import { parse } from '@typescript-eslint/typescript-estree';
+import { createChunksFromCode } from '../../utils/chunking.js';
+import { CODEBASE_CONTEXT_DIRNAME, KEYWORD_INDEX_FILENAME } from '../../constants/codebase-context.js';
 export class AngularAnalyzer {
-    name = "angular";
-    version = "1.0.0";
-    supportedExtensions = [
-        ".ts",
-        ".js",
-        ".html",
-        ".scss",
-        ".css",
-        ".sass",
-        ".less",
-    ];
+    name = 'angular';
+    version = '1.0.0';
+    supportedExtensions = ['.ts', '.js', '.html', '.scss', '.css', '.sass', '.less'];
     priority = 100; // Highest priority for Angular files
     angularPatterns = {
         component: /@Component\s*\(/,
@@ -30,14 +24,14 @@ export class AngularAnalyzer {
         guard: /(?:implements\s+(?:CanActivate|CanDeactivate|CanLoad|CanMatch)|canActivate\s*\(|canDeactivate\s*\(|canLoad\s*\(|canMatch\s*\(|CanActivateFn|CanDeactivateFn|CanMatchFn)/,
         interceptor: /(?:implements\s+HttpInterceptor|intercept\s*\(|HttpInterceptorFn)/,
         resolver: /(?:implements\s+Resolve|resolve\s*\(|ResolveFn)/,
-        validator: /(?:implements\s+(?:Validator|AsyncValidator)|validate\s*\()/,
+        validator: /(?:implements\s+(?:Validator|AsyncValidator)|validate\s*\()/
     };
     stateManagementPatterns = {
         ngrx: /@ngrx\/store|createAction|createReducer|createSelector/,
         akita: /@datorama\/akita|Query|Store\.update/,
         elf: /@ngneat\/elf|createStore|withEntities/,
         signals: /\bsignal\s*[<(]|\bcomputed\s*[<(]|\beffect\s*\(|\blinkedSignal\s*[<(]/,
-        rxjsState: /BehaviorSubject|ReplaySubject|shareReplay/,
+        rxjsState: /BehaviorSubject|ReplaySubject|shareReplay/
     };
     modernAngularPatterns = {
         signalInput: /\binput\s*[<(]|\binput\.required\s*[<(]/,
@@ -51,7 +45,7 @@ export class AngularAnalyzer {
         controlFlowFor: /@for\s*\(/,
         controlFlowSwitch: /@switch\s*\(/,
         controlFlowDefer: /@defer\s*[({]/,
-        injectFunction: /\binject\s*[<(]/,
+        injectFunction: /\binject\s*[<(]/
     };
     canAnalyze(filePath, content) {
         const ext = path.extname(filePath).toLowerCase();
@@ -59,13 +53,13 @@ export class AngularAnalyzer {
             return false;
         }
         // For TypeScript files, check if it contains Angular decorators
-        if (ext === ".ts" && content) {
+        if (ext === '.ts' && content) {
             return Object.values(this.angularPatterns).some((pattern) => pattern.test(content));
         }
         // Angular component templates and styles
-        if ([".html", ".scss", ".css", ".sass", ".less"].includes(ext)) {
+        if (['.html', '.scss', '.css', '.sass', '.less'].includes(ext)) {
             // Check if there's a corresponding .ts file
-            const baseName = filePath.replace(/\.(html|scss|css|sass|less)$/, "");
+            // const baseName = filePath.replace(/\.(html|scss|css|sass|less)$/, '');
             return true; // We'll verify during analysis
         }
         return false;
@@ -73,26 +67,26 @@ export class AngularAnalyzer {
     async analyze(filePath, content) {
         const ext = path.extname(filePath).toLowerCase();
         const relativePath = path.relative(process.cwd(), filePath);
-        if (ext === ".ts") {
+        if (ext === '.ts') {
             return this.analyzeTypeScriptFile(filePath, content, relativePath);
         }
-        else if (ext === ".html") {
+        else if (ext === '.html') {
             return this.analyzeTemplateFile(filePath, content, relativePath);
         }
-        else if ([".scss", ".css", ".sass", ".less"].includes(ext)) {
+        else if (['.scss', '.css', '.sass', '.less'].includes(ext)) {
             return this.analyzeStyleFile(filePath, content, relativePath);
         }
         // Fallback
         return {
             filePath,
-            language: "unknown",
-            framework: "angular",
+            language: 'unknown',
+            framework: 'angular',
             components: [],
             imports: [],
             exports: [],
             dependencies: [],
             metadata: {},
-            chunks: [],
+            chunks: []
         };
     }
     async analyzeTypeScriptFile(filePath, content, relativePath) {
@@ -104,33 +98,33 @@ export class AngularAnalyzer {
             const ast = parse(content, {
                 loc: true,
                 range: true,
-                comment: true,
+                comment: true
             });
             // Extract imports
             for (const node of ast.body) {
-                if (node.type === "ImportDeclaration" && node.source.value) {
+                if (node.type === 'ImportDeclaration' && node.source.value) {
                     const source = node.source.value;
                     imports.push({
                         source,
                         imports: node.specifiers.map((s) => {
-                            if (s.type === "ImportDefaultSpecifier")
-                                return "default";
-                            if (s.type === "ImportNamespaceSpecifier")
-                                return "*";
+                            if (s.type === 'ImportDefaultSpecifier')
+                                return 'default';
+                            if (s.type === 'ImportNamespaceSpecifier')
+                                return '*';
                             return s.imported?.name || s.local.name;
                         }),
-                        isDefault: node.specifiers.some((s) => s.type === "ImportDefaultSpecifier"),
+                        isDefault: node.specifiers.some((s) => s.type === 'ImportDefaultSpecifier'),
                         isDynamic: false,
-                        line: node.loc?.start.line,
+                        line: node.loc?.start.line
                     });
                     // Track dependencies
-                    if (!source.startsWith(".") && !source.startsWith("/")) {
-                        dependencies.push(source.split("/")[0]);
+                    if (!source.startsWith('.') && !source.startsWith('/')) {
+                        dependencies.push(source.split('/')[0]);
                     }
                 }
                 // Extract class declarations with decorators
-                if (node.type === "ExportNamedDeclaration" &&
-                    node.declaration?.type === "ClassDeclaration") {
+                if (node.type === 'ExportNamedDeclaration' &&
+                    node.declaration?.type === 'ClassDeclaration') {
                     const classNode = node.declaration;
                     if (classNode.id && classNode.decorators) {
                         const component = await this.extractAngularComponent(classNode, content);
@@ -140,33 +134,30 @@ export class AngularAnalyzer {
                     }
                 }
                 // Handle direct class exports
-                if (node.type === "ClassDeclaration" && node.id && node.decorators) {
+                if (node.type === 'ClassDeclaration' && node.id && node.decorators) {
                     const component = await this.extractAngularComponent(node, content);
                     if (component) {
                         components.push(component);
                     }
                 }
                 // Extract exports
-                if (node.type === "ExportNamedDeclaration") {
+                if (node.type === 'ExportNamedDeclaration') {
                     if (node.declaration) {
-                        if (node.declaration.type === "ClassDeclaration" &&
-                            node.declaration.id) {
+                        if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
                             exports.push({
                                 name: node.declaration.id.name,
                                 isDefault: false,
-                                type: "class",
+                                type: 'class'
                             });
                         }
                     }
                 }
-                if (node.type === "ExportDefaultDeclaration") {
-                    const name = node.declaration.type === "Identifier"
-                        ? node.declaration.name
-                        : "default";
+                if (node.type === 'ExportDefaultDeclaration') {
+                    const name = node.declaration.type === 'Identifier' ? node.declaration.name : 'default';
                     exports.push({
                         name,
                         isDefault: true,
-                        type: "default",
+                        type: 'default'
                     });
                 }
             }
@@ -181,77 +172,80 @@ export class AngularAnalyzer {
         // Determine architectural layer
         const layer = this.determineLayer(filePath, components);
         // Create chunks with Angular-specific metadata
-        const chunks = await createChunksFromCode(content, filePath, relativePath, "typescript", components, {
-            framework: "angular",
+        const chunks = await createChunksFromCode(content, filePath, relativePath, 'typescript', components, {
+            framework: 'angular',
             layer,
             statePattern,
             dependencies,
-            modernPatterns,
+            modernPatterns
         });
         // Build detected patterns for the indexer to forward
         const detectedPatterns = [];
         // Dependency Injection pattern
-        if (modernPatterns.includes("injectFunction")) {
-            detectedPatterns.push({ category: "dependencyInjection", name: "inject() function" });
+        if (modernPatterns.includes('injectFunction')) {
+            detectedPatterns.push({ category: 'dependencyInjection', name: 'inject() function' });
         }
-        else if (content.includes("constructor(") && content.includes("private") &&
-            (relativePath.endsWith(".service.ts") || relativePath.endsWith(".component.ts"))) {
-            detectedPatterns.push({ category: "dependencyInjection", name: "Constructor injection" });
+        else if (content.includes('constructor(') &&
+            content.includes('private') &&
+            (relativePath.endsWith('.service.ts') || relativePath.endsWith('.component.ts'))) {
+            detectedPatterns.push({ category: 'dependencyInjection', name: 'Constructor injection' });
         }
         // State Management pattern
         if (/BehaviorSubject|ReplaySubject|Subject|Observable/.test(content)) {
-            detectedPatterns.push({ category: "stateManagement", name: "RxJS" });
+            detectedPatterns.push({ category: 'stateManagement', name: 'RxJS' });
         }
-        if (modernPatterns.some((p) => p.startsWith("signal"))) {
-            detectedPatterns.push({ category: "stateManagement", name: "Signals" });
+        if (modernPatterns.some((p) => p.startsWith('signal'))) {
+            detectedPatterns.push({ category: 'stateManagement', name: 'Signals' });
         }
         // Reactivity patterns
         if (/\beffect\s*\(/.test(content)) {
-            detectedPatterns.push({ category: "reactivity", name: "Effect" });
+            detectedPatterns.push({ category: 'reactivity', name: 'Effect' });
         }
         if (/\bcomputed\s*[<(]/.test(content)) {
-            detectedPatterns.push({ category: "reactivity", name: "Computed" });
+            detectedPatterns.push({ category: 'reactivity', name: 'Computed' });
         }
         // Component Style pattern detection
         // Logic: explicit standalone: true → Standalone
         //        explicit standalone: false → NgModule-based
         //        no explicit flag + uses modern patterns (inject, signals) → likely Standalone (Angular v19+ default)
         //        no explicit flag + no modern patterns → ambiguous, don't classify
-        const hasExplicitStandalone = content.includes("standalone: true");
-        const hasExplicitNgModule = content.includes("standalone: false");
-        const usesModernPatterns = modernPatterns.includes("injectFunction") ||
-            modernPatterns.some(p => p.startsWith("signal"));
-        if (relativePath.endsWith("component.ts") || relativePath.endsWith("directive.ts") || relativePath.endsWith("pipe.ts")) {
+        const hasExplicitStandalone = content.includes('standalone: true');
+        const hasExplicitNgModule = content.includes('standalone: false');
+        const usesModernPatterns = modernPatterns.includes('injectFunction') ||
+            modernPatterns.some((p) => p.startsWith('signal'));
+        if (relativePath.endsWith('component.ts') ||
+            relativePath.endsWith('directive.ts') ||
+            relativePath.endsWith('pipe.ts')) {
             if (hasExplicitStandalone) {
-                detectedPatterns.push({ category: "componentStyle", name: "Standalone" });
+                detectedPatterns.push({ category: 'componentStyle', name: 'Standalone' });
             }
             else if (hasExplicitNgModule) {
-                detectedPatterns.push({ category: "componentStyle", name: "NgModule-based" });
+                detectedPatterns.push({ category: 'componentStyle', name: 'NgModule-based' });
             }
             else if (usesModernPatterns) {
                 // No explicit flag but uses modern patterns → likely v19+ standalone default
-                detectedPatterns.push({ category: "componentStyle", name: "Standalone" });
+                detectedPatterns.push({ category: 'componentStyle', name: 'Standalone' });
             }
             // If no explicit flag and no modern patterns, don't classify (ambiguous)
         }
         // Input style pattern
-        if (modernPatterns.includes("signalInput")) {
-            detectedPatterns.push({ category: "componentInputs", name: "Signal-based inputs" });
+        if (modernPatterns.includes('signalInput')) {
+            detectedPatterns.push({ category: 'componentInputs', name: 'Signal-based inputs' });
         }
-        else if (content.includes("@Input()")) {
-            detectedPatterns.push({ category: "componentInputs", name: "Decorator-based @Input" });
+        else if (content.includes('@Input()')) {
+            detectedPatterns.push({ category: 'componentInputs', name: 'Decorator-based @Input' });
         }
         return {
             filePath,
-            language: "typescript",
-            framework: "angular",
+            language: 'typescript',
+            framework: 'angular',
             components,
             imports,
             exports,
             dependencies: dependencies.map((name) => ({
                 name,
                 category: this.categorizeDependency(name),
-                layer,
+                layer
             })),
             metadata: {
                 analyzer: this.name,
@@ -259,22 +253,22 @@ export class AngularAnalyzer {
                 statePattern,
                 modernPatterns,
                 // isStandalone: true if explicit standalone: true, or if uses modern patterns (implying v19+ default)
-                isStandalone: content.includes("standalone: true") ||
-                    (!content.includes("standalone: false") &&
-                        (modernPatterns.includes("injectFunction") || modernPatterns.some(p => p.startsWith("signal")))),
-                hasRoutes: content.includes("RouterModule") || content.includes("routes"),
-                usesSignals: modernPatterns.length > 0 &&
-                    modernPatterns.some((p) => p.startsWith("signal")),
-                usesControlFlow: modernPatterns.some((p) => p.startsWith("controlFlow")),
-                usesInject: modernPatterns.includes("injectFunction"),
+                isStandalone: content.includes('standalone: true') ||
+                    (!content.includes('standalone: false') &&
+                        (modernPatterns.includes('injectFunction') ||
+                            modernPatterns.some((p) => p.startsWith('signal')))),
+                hasRoutes: content.includes('RouterModule') || content.includes('routes'),
+                usesSignals: modernPatterns.length > 0 && modernPatterns.some((p) => p.startsWith('signal')),
+                usesControlFlow: modernPatterns.some((p) => p.startsWith('controlFlow')),
+                usesInject: modernPatterns.includes('injectFunction'),
                 usesRxJS: /BehaviorSubject|ReplaySubject|Subject|Observable/.test(content),
                 usesEffect: /\beffect\s*\(/.test(content),
                 usesComputed: /\bcomputed\s*[<(]/.test(content),
                 componentType: components.length > 0 ? components[0].metadata.angularType : undefined,
                 // NEW: Patterns for the indexer to forward generically
-                detectedPatterns,
+                detectedPatterns
             },
-            chunks,
+            chunks
         };
     }
     /**
@@ -298,66 +292,66 @@ export class AngularAnalyzer {
         let componentType;
         let angularType;
         // Determine Angular component type
-        if (decoratorName === "Component") {
-            componentType = "component";
-            angularType = "component";
+        if (decoratorName === 'Component') {
+            componentType = 'component';
+            angularType = 'component';
         }
-        else if (decoratorName === "Directive") {
-            componentType = "directive";
-            angularType = "directive";
+        else if (decoratorName === 'Directive') {
+            componentType = 'directive';
+            angularType = 'directive';
         }
-        else if (decoratorName === "Pipe") {
-            componentType = "pipe";
-            angularType = "pipe";
+        else if (decoratorName === 'Pipe') {
+            componentType = 'pipe';
+            angularType = 'pipe';
         }
-        else if (decoratorName === "NgModule") {
-            componentType = "module";
-            angularType = "module";
+        else if (decoratorName === 'NgModule') {
+            componentType = 'module';
+            angularType = 'module';
         }
-        else if (decoratorName === "Injectable") {
+        else if (decoratorName === 'Injectable') {
             // For @Injectable, check if it's actually a guard/interceptor/resolver/validator
             // before defaulting to 'service'
             const classContent = content.substring(classNode.range[0], classNode.range[1]);
             if (this.angularPatterns.guard.test(classContent)) {
-                componentType = "guard";
-                angularType = "guard";
+                componentType = 'guard';
+                angularType = 'guard';
             }
             else if (this.angularPatterns.interceptor.test(classContent)) {
-                componentType = "interceptor";
-                angularType = "interceptor";
+                componentType = 'interceptor';
+                angularType = 'interceptor';
             }
             else if (this.angularPatterns.resolver.test(classContent)) {
-                componentType = "resolver";
-                angularType = "resolver";
+                componentType = 'resolver';
+                angularType = 'resolver';
             }
             else if (this.angularPatterns.validator.test(classContent)) {
-                componentType = "validator";
-                angularType = "validator";
+                componentType = 'validator';
+                angularType = 'validator';
             }
             else {
                 // Default to service if no specific pattern matches
-                componentType = "service";
-                angularType = "service";
+                componentType = 'service';
+                angularType = 'service';
             }
         }
         // If still no type, check patterns one more time (for classes without decorators)
         if (!componentType) {
             const classContent = content.substring(classNode.range[0], classNode.range[1]);
             if (this.angularPatterns.guard.test(classContent)) {
-                componentType = "guard";
-                angularType = "guard";
+                componentType = 'guard';
+                angularType = 'guard';
             }
             else if (this.angularPatterns.interceptor.test(classContent)) {
-                componentType = "interceptor";
-                angularType = "interceptor";
+                componentType = 'interceptor';
+                angularType = 'interceptor';
             }
             else if (this.angularPatterns.resolver.test(classContent)) {
-                componentType = "resolver";
-                angularType = "resolver";
+                componentType = 'resolver';
+                angularType = 'resolver';
             }
             else if (this.angularPatterns.validator.test(classContent)) {
-                componentType = "validator";
-                angularType = "validator";
+                componentType = 'validator';
+                angularType = 'validator';
             }
         }
         // Extract decorator metadata
@@ -371,15 +365,15 @@ export class AngularAnalyzer {
         const outputs = this.extractOutputs(classNode);
         return {
             name: classNode.id.name,
-            type: "class",
+            type: 'class',
             componentType,
             startLine: classNode.loc.start.line,
             endLine: classNode.loc.end.line,
             decorators: [
                 {
                     name: decoratorName,
-                    properties: decoratorMetadata,
-                },
+                    properties: decoratorMetadata
+                }
             ],
             lifecycle,
             dependencies: injectedServices,
@@ -392,8 +386,8 @@ export class AngularAnalyzer {
                 templateUrl: decoratorMetadata.templateUrl,
                 styleUrls: decoratorMetadata.styleUrls,
                 inputs: inputs.map((i) => i.name),
-                outputs: outputs.map((o) => o.name),
-            },
+                outputs: outputs.map((o) => o.name)
+            }
         };
     }
     extractDecoratorMetadata(decorator) {
@@ -401,19 +395,19 @@ export class AngularAnalyzer {
         try {
             if (decorator.expression.arguments && decorator.expression.arguments[0]) {
                 const arg = decorator.expression.arguments[0];
-                if (arg.type === "ObjectExpression") {
+                if (arg.type === 'ObjectExpression') {
                     for (const prop of arg.properties) {
                         if (prop.key && prop.value) {
                             const key = prop.key.name || prop.key.value;
-                            if (prop.value.type === "Literal") {
+                            if (prop.value.type === 'Literal') {
                                 metadata[key] = prop.value.value;
                             }
-                            else if (prop.value.type === "ArrayExpression") {
+                            else if (prop.value.type === 'ArrayExpression') {
                                 metadata[key] = prop.value.elements
-                                    .map((el) => (el.type === "Literal" ? el.value : null))
+                                    .map((el) => (el.type === 'Literal' ? el.value : null))
                                     .filter(Boolean);
                             }
-                            else if (prop.value.type === "Identifier") {
+                            else if (prop.value.type === 'Identifier') {
                                 metadata[key] = prop.value.name;
                             }
                         }
@@ -422,25 +416,25 @@ export class AngularAnalyzer {
             }
         }
         catch (error) {
-            console.warn("Failed to extract decorator metadata:", error);
+            console.warn('Failed to extract decorator metadata:', error);
         }
         return metadata;
     }
     extractLifecycleHooks(classNode) {
         const hooks = [];
         const lifecycleHooks = [
-            "ngOnChanges",
-            "ngOnInit",
-            "ngDoCheck",
-            "ngAfterContentInit",
-            "ngAfterContentChecked",
-            "ngAfterViewInit",
-            "ngAfterViewChecked",
-            "ngOnDestroy",
+            'ngOnChanges',
+            'ngOnInit',
+            'ngDoCheck',
+            'ngAfterContentInit',
+            'ngAfterContentChecked',
+            'ngAfterViewInit',
+            'ngAfterViewChecked',
+            'ngOnDestroy'
         ];
         if (classNode.body && classNode.body.body) {
             for (const member of classNode.body.body) {
-                if (member.type === "MethodDefinition" && member.key) {
+                if (member.type === 'MethodDefinition' && member.key) {
                     const methodName = member.key.name;
                     if (lifecycleHooks.includes(methodName)) {
                         hooks.push(methodName);
@@ -455,8 +449,7 @@ export class AngularAnalyzer {
         // Look for constructor parameters
         if (classNode.body && classNode.body.body) {
             for (const member of classNode.body.body) {
-                if (member.type === "MethodDefinition" &&
-                    member.kind === "constructor") {
+                if (member.type === 'MethodDefinition' && member.kind === 'constructor') {
                     if (member.value.params) {
                         for (const param of member.value.params) {
                             if (param.typeAnnotation?.typeAnnotation?.typeName) {
@@ -473,30 +466,29 @@ export class AngularAnalyzer {
         const inputs = [];
         if (classNode.body && classNode.body.body) {
             for (const member of classNode.body.body) {
-                if (member.type === "PropertyDefinition") {
+                if (member.type === 'PropertyDefinition') {
                     // Check for decorator-based @Input()
                     if (member.decorators) {
-                        const hasInput = member.decorators.some((d) => d.expression?.callee?.name === "Input" ||
-                            d.expression?.name === "Input");
+                        const hasInput = member.decorators.some((d) => d.expression?.callee?.name === 'Input' || d.expression?.name === 'Input');
                         if (hasInput && member.key) {
                             inputs.push({
                                 name: member.key.name,
-                                type: member.typeAnnotation?.typeAnnotation?.type || "any",
-                                style: "decorator",
+                                type: member.typeAnnotation?.typeAnnotation?.type || 'any',
+                                style: 'decorator'
                             });
                         }
                     }
                     // Check for signal-based input() (Angular v17.1+)
                     if (member.value && member.key) {
-                        const valueStr = member.value.type === "CallExpression"
+                        const valueStr = member.value.type === 'CallExpression'
                             ? member.value.callee?.name || member.value.callee?.object?.name
                             : null;
-                        if (valueStr === "input") {
+                        if (valueStr === 'input') {
                             inputs.push({
                                 name: member.key.name,
-                                type: "InputSignal",
-                                style: "signal",
-                                required: member.value.callee?.property?.name === "required",
+                                type: 'InputSignal',
+                                style: 'signal',
+                                required: member.value.callee?.property?.name === 'required'
                             });
                         }
                     }
@@ -509,29 +501,26 @@ export class AngularAnalyzer {
         const outputs = [];
         if (classNode.body && classNode.body.body) {
             for (const member of classNode.body.body) {
-                if (member.type === "PropertyDefinition") {
+                if (member.type === 'PropertyDefinition') {
                     // Check for decorator-based @Output()
                     if (member.decorators) {
-                        const hasOutput = member.decorators.some((d) => d.expression?.callee?.name === "Output" ||
-                            d.expression?.name === "Output");
+                        const hasOutput = member.decorators.some((d) => d.expression?.callee?.name === 'Output' || d.expression?.name === 'Output');
                         if (hasOutput && member.key) {
                             outputs.push({
                                 name: member.key.name,
-                                type: "EventEmitter",
-                                style: "decorator",
+                                type: 'EventEmitter',
+                                style: 'decorator'
                             });
                         }
                     }
                     // Check for signal-based output() (Angular v17.1+)
                     if (member.value && member.key) {
-                        const valueStr = member.value.type === "CallExpression"
-                            ? member.value.callee?.name
-                            : null;
-                        if (valueStr === "output") {
+                        const valueStr = member.value.type === 'CallExpression' ? member.value.callee?.name : null;
+                        if (valueStr === 'output') {
                             outputs.push({
                                 name: member.key.name,
-                                type: "OutputEmitterRef",
-                                style: "signal",
+                                type: 'OutputEmitterRef',
+                                style: 'signal'
                             });
                         }
                     }
@@ -542,28 +531,28 @@ export class AngularAnalyzer {
     }
     async analyzeTemplateFile(filePath, content, relativePath) {
         // Find corresponding component file
-        const componentPath = filePath.replace(/\.html$/, ".ts");
+        const componentPath = filePath.replace(/\.html$/, '.ts');
         // Detect legacy vs modern control flow
         const hasLegacyDirectives = /\*ng(?:If|For|Switch)/.test(content);
         const hasModernControlFlow = /@(?:if|for|switch|defer)\s*[({]/.test(content);
         return {
             filePath,
-            language: "html",
-            framework: "angular",
+            language: 'html',
+            framework: 'angular',
             components: [],
             imports: [],
             exports: [],
             dependencies: [],
             metadata: {
                 analyzer: this.name,
-                type: "template",
+                type: 'template',
                 componentPath,
                 hasLegacyDirectives,
                 hasModernControlFlow,
                 hasBindings: /\[|\(|{{/.test(content),
-                hasDefer: /@defer\s*[({]/.test(content),
+                hasDefer: /@defer\s*[({]/.test(content)
             },
-            chunks: await createChunksFromCode(content, filePath, relativePath, "html", []),
+            chunks: await createChunksFromCode(content, filePath, relativePath, 'html', [])
         };
     }
     async analyzeStyleFile(filePath, content, relativePath) {
@@ -572,16 +561,16 @@ export class AngularAnalyzer {
         return {
             filePath,
             language,
-            framework: "angular",
+            framework: 'angular',
             components: [],
             imports: [],
             exports: [],
             dependencies: [],
             metadata: {
                 analyzer: this.name,
-                type: "style",
+                type: 'style'
             },
-            chunks: await createChunksFromCode(content, filePath, relativePath, language, []),
+            chunks: await createChunksFromCode(content, filePath, relativePath, language, [])
         };
     }
     detectStateManagement(content) {
@@ -595,79 +584,72 @@ export class AngularAnalyzer {
     determineLayer(filePath, components) {
         const lowerPath = filePath.toLowerCase();
         // Check path-based patterns
-        if (lowerPath.includes("/component") ||
-            lowerPath.includes("/view") ||
-            lowerPath.includes("/page")) {
-            return "presentation";
+        if (lowerPath.includes('/component') ||
+            lowerPath.includes('/view') ||
+            lowerPath.includes('/page')) {
+            return 'presentation';
         }
-        if (lowerPath.includes("/service")) {
-            return "business";
+        if (lowerPath.includes('/service')) {
+            return 'business';
         }
-        if (lowerPath.includes("/data") ||
-            lowerPath.includes("/repository") ||
-            lowerPath.includes("/api")) {
-            return "data";
+        if (lowerPath.includes('/data') ||
+            lowerPath.includes('/repository') ||
+            lowerPath.includes('/api')) {
+            return 'data';
         }
-        if (lowerPath.includes("/store") ||
-            lowerPath.includes("/state") ||
-            lowerPath.includes("/ngrx")) {
-            return "state";
+        if (lowerPath.includes('/store') ||
+            lowerPath.includes('/state') ||
+            lowerPath.includes('/ngrx')) {
+            return 'state';
         }
-        if (lowerPath.includes("/core")) {
-            return "core";
+        if (lowerPath.includes('/core')) {
+            return 'core';
         }
-        if (lowerPath.includes("/shared")) {
-            return "shared";
+        if (lowerPath.includes('/shared')) {
+            return 'shared';
         }
-        if (lowerPath.includes("/feature")) {
-            return "feature";
+        if (lowerPath.includes('/feature')) {
+            return 'feature';
         }
         // Check component types
         for (const component of components) {
-            if (component.componentType === "component" ||
-                component.componentType === "directive" ||
-                component.componentType === "pipe") {
-                return "presentation";
+            if (component.componentType === 'component' ||
+                component.componentType === 'directive' ||
+                component.componentType === 'pipe') {
+                return 'presentation';
             }
-            if (component.componentType === "service") {
-                return lowerPath.includes("http") || lowerPath.includes("api")
-                    ? "data"
-                    : "business";
+            if (component.componentType === 'service') {
+                return lowerPath.includes('http') || lowerPath.includes('api') ? 'data' : 'business';
             }
-            if (component.componentType === "guard" ||
-                component.componentType === "interceptor") {
-                return "core";
+            if (component.componentType === 'guard' || component.componentType === 'interceptor') {
+                return 'core';
             }
         }
-        return "unknown";
+        return 'unknown';
     }
     categorizeDependency(name) {
-        if (name.startsWith("@angular/")) {
-            return "framework";
+        if (name.startsWith('@angular/')) {
+            return 'framework';
         }
-        if (name.includes("ngrx") ||
-            name.includes("akita") ||
-            name.includes("elf")) {
-            return "state";
+        if (name.includes('ngrx') || name.includes('akita') || name.includes('elf')) {
+            return 'state';
         }
-        if (name.includes("material") ||
-            name.includes("primeng") ||
-            name.includes("ng-bootstrap")) {
-            return "ui";
+        if (name.includes('material') || name.includes('primeng') || name.includes('ng-bootstrap')) {
+            return 'ui';
         }
-        if (name.includes("router")) {
-            return "routing";
+        if (name.includes('router')) {
+            return 'routing';
         }
-        if (name.includes("http") || name.includes("common/http")) {
-            return "http";
+        if (name.includes('http') || name.includes('common/http')) {
+            return 'http';
         }
-        if (name.includes("test") ||
-            name.includes("jest") ||
-            name.includes("jasmine") ||
-            name.includes("karma")) {
-            return "testing";
+        if (name.includes('test') ||
+            name.includes('jest') ||
+            name.includes('jasmine') ||
+            name.includes('karma')) {
+            return 'testing';
         }
-        return "other";
+        return 'other';
     }
     async detectCodebaseMetadata(rootPath) {
         const metadata = {
@@ -676,7 +658,7 @@ export class AngularAnalyzer {
             languages: [],
             dependencies: [],
             architecture: {
-                type: "feature-based",
+                type: 'feature-based',
                 layers: {
                     presentation: 0,
                     business: 0,
@@ -686,14 +668,14 @@ export class AngularAnalyzer {
                     shared: 0,
                     feature: 0,
                     infrastructure: 0,
-                    unknown: 0,
+                    unknown: 0
                 },
-                patterns: [],
+                patterns: []
             },
             styleGuides: [],
             documentation: [],
             projectStructure: {
-                type: "single-app",
+                type: 'single-app'
             },
             statistics: {
                 totalFiles: 0,
@@ -709,69 +691,69 @@ export class AngularAnalyzer {
                     shared: 0,
                     feature: 0,
                     infrastructure: 0,
-                    unknown: 0,
-                },
+                    unknown: 0
+                }
             },
-            customMetadata: {},
+            customMetadata: {}
         };
         try {
             // Read package.json
-            const packageJsonPath = path.join(rootPath, "package.json");
-            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+            const packageJsonPath = path.join(rootPath, 'package.json');
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
             metadata.name = packageJson.name || metadata.name;
             // Extract Angular version and dependencies
             const allDeps = {
                 ...packageJson.dependencies,
-                ...packageJson.devDependencies,
+                ...packageJson.devDependencies
             };
-            const angularVersion = allDeps["@angular/core"]?.replace(/[\^~]/, "") || "unknown";
+            const angularVersion = allDeps['@angular/core']?.replace(/[\^~]/, '') || 'unknown';
             // Detect state management
             const stateManagement = [];
-            if (allDeps["@ngrx/store"])
-                stateManagement.push("ngrx");
-            if (allDeps["@datorama/akita"])
-                stateManagement.push("akita");
-            if (allDeps["@ngneat/elf"])
-                stateManagement.push("elf");
+            if (allDeps['@ngrx/store'])
+                stateManagement.push('ngrx');
+            if (allDeps['@datorama/akita'])
+                stateManagement.push('akita');
+            if (allDeps['@ngneat/elf'])
+                stateManagement.push('elf');
             // Detect UI libraries
             const uiLibraries = [];
-            if (allDeps["@angular/material"])
-                uiLibraries.push("Angular Material");
-            if (allDeps["primeng"])
-                uiLibraries.push("PrimeNG");
-            if (allDeps["@ng-bootstrap/ng-bootstrap"])
-                uiLibraries.push("ng-bootstrap");
+            if (allDeps['@angular/material'])
+                uiLibraries.push('Angular Material');
+            if (allDeps['primeng'])
+                uiLibraries.push('PrimeNG');
+            if (allDeps['@ng-bootstrap/ng-bootstrap'])
+                uiLibraries.push('ng-bootstrap');
             // Detect testing frameworks
             const testingFrameworks = [];
-            if (allDeps["jasmine-core"])
-                testingFrameworks.push("Jasmine");
-            if (allDeps["karma"])
-                testingFrameworks.push("Karma");
-            if (allDeps["jest"])
-                testingFrameworks.push("Jest");
+            if (allDeps['jasmine-core'])
+                testingFrameworks.push('Jasmine');
+            if (allDeps['karma'])
+                testingFrameworks.push('Karma');
+            if (allDeps['jest'])
+                testingFrameworks.push('Jest');
             metadata.framework = {
-                name: "Angular",
+                name: 'Angular',
                 version: angularVersion,
-                type: "angular",
-                variant: "unknown", // Will be determined during analysis
+                type: 'angular',
+                variant: 'unknown', // Will be determined during analysis
                 stateManagement,
                 uiLibraries,
-                testingFrameworks,
+                testingFrameworks
             };
             // Convert dependencies
             metadata.dependencies = Object.entries(allDeps).map(([name, version]) => ({
                 name,
                 version: version,
-                category: this.categorizeDependency(name),
+                category: this.categorizeDependency(name)
             }));
         }
         catch (error) {
-            console.warn("Failed to read Angular project metadata:", error);
+            console.warn('Failed to read Angular project metadata:', error);
         }
         // Calculate statistics from existing index if available
         try {
-            const indexPath = path.join(rootPath, ".codebase-index.json");
-            const indexContent = await fs.readFile(indexPath, "utf-8");
+            const indexPath = path.join(rootPath, CODEBASE_CONTEXT_DIRNAME, KEYWORD_INDEX_FILENAME);
+            const indexContent = await fs.readFile(indexPath, 'utf-8');
             const chunks = JSON.parse(indexContent);
             console.error(`Loading statistics from ${indexPath}: ${chunks.length} chunks`);
             if (Array.isArray(chunks) && chunks.length > 0) {
@@ -788,12 +770,11 @@ export class AngularAnalyzer {
                     shared: 0,
                     feature: 0,
                     infrastructure: 0,
-                    unknown: 0,
+                    unknown: 0
                 };
                 for (const chunk of chunks) {
                     if (chunk.componentType) {
-                        componentCounts[chunk.componentType] =
-                            (componentCounts[chunk.componentType] || 0) + 1;
+                        componentCounts[chunk.componentType] = (componentCounts[chunk.componentType] || 0) + 1;
                         metadata.statistics.totalComponents++;
                     }
                     if (chunk.layer) {
@@ -808,7 +789,7 @@ export class AngularAnalyzer {
         }
         catch (error) {
             // Index doesn't exist yet, keep statistics at 0
-            console.warn("Failed to calculate statistics from index:", error);
+            console.warn('Failed to calculate statistics from index:', error);
         }
         return metadata;
     }
@@ -822,101 +803,109 @@ export class AngularAnalyzer {
         const classMatch = content.match(/(?:export\s+)?class\s+(\w+)/);
         const className = classMatch ? classMatch[1] : fileName;
         switch (componentType) {
-            case "component":
-                const selector = metadata.decorator?.selector || "unknown";
+            case 'component': {
+                const selector = metadata.decorator?.selector || 'unknown';
                 const inputs = metadata.decorator?.inputs?.length || 0;
                 const outputs = metadata.decorator?.outputs?.length || 0;
                 const lifecycle = this.extractLifecycleMethods(content);
-                return `Angular component '${className}' (selector: ${selector})${lifecycle ? ` with ${lifecycle}` : ""}${inputs ? `, ${inputs} inputs` : ""}${outputs ? `, ${outputs} outputs` : ""}.`;
-            case "service":
-                const providedIn = metadata.decorator?.providedIn || "unknown";
+                return `Angular component '${className}' (selector: ${selector})${lifecycle ? ` with ${lifecycle}` : ''}${inputs ? `, ${inputs} inputs` : ''}${outputs ? `, ${outputs} outputs` : ''}.`;
+            }
+            case 'service': {
+                const providedIn = metadata.decorator?.providedIn || 'unknown';
                 const methods = this.extractPublicMethods(content);
-                return `Angular service '${className}' (providedIn: ${providedIn})${methods ? ` providing ${methods}` : ""}.`;
-            case "guard":
+                return `Angular service '${className}' (providedIn: ${providedIn})${methods ? ` providing ${methods}` : ''}.`;
+            }
+            case 'guard': {
                 const guardType = this.detectGuardType(content);
                 return `Angular ${guardType} guard '${className}' protecting routes.`;
-            case "directive":
-                const directiveSelector = metadata.decorator?.selector || "unknown";
+            }
+            case 'directive': {
+                const directiveSelector = metadata.decorator?.selector || 'unknown';
                 return `Angular directive '${className}' (selector: ${directiveSelector}).`;
-            case "pipe":
-                const pipeName = metadata.decorator?.name || "unknown";
+            }
+            case 'pipe': {
+                const pipeName = metadata.decorator?.name || 'unknown';
                 return `Angular pipe '${className}' (name: ${pipeName}) for data transformation.`;
-            case "module":
+            }
+            case 'module': {
                 const imports = metadata.decorator?.imports?.length || 0;
                 const declarations = metadata.decorator?.declarations?.length || 0;
                 return `Angular module '${className}' with ${declarations} declarations and ${imports} imports.`;
-            case "interceptor":
+            }
+            case 'interceptor':
                 return `Angular HTTP interceptor '${className}' modifying HTTP requests/responses.`;
-            case "resolver":
+            case 'resolver':
                 return `Angular resolver '${className}' pre-fetching route data.`;
-            case "validator":
+            case 'validator':
                 return `Angular validator '${className}' for form validation.`;
             default:
                 // Try to provide a meaningful fallback
                 if (className && className !== fileName) {
                     // Check for common patterns
-                    if (content.includes("signal(") ||
-                        content.includes("computed(") ||
-                        content.includes("effect(")) {
+                    if (content.includes('signal(') ||
+                        content.includes('computed(') ||
+                        content.includes('effect(')) {
                         return `Angular code '${className}' using signals.`;
                     }
-                    if (content.includes("inject(")) {
+                    if (content.includes('inject(')) {
                         return `Angular code '${className}' using dependency injection.`;
                     }
-                    if (content.includes("Observable") || content.includes("Subject")) {
+                    if (content.includes('Observable') || content.includes('Subject')) {
                         return `Angular code '${className}' with reactive streams.`;
                     }
                     return `Angular code '${className}' in ${fileName}.`;
                 }
-                // Extract first meaningful export or declaration
-                const exportMatch = content.match(/export\s+(?:const|function|class|interface|type|enum)\s+(\w+)/);
-                if (exportMatch) {
-                    return `Exports '${exportMatch[1]}' from ${fileName}.`;
+                {
+                    // Extract first meaningful export or declaration
+                    const exportMatch = content.match(/export\s+(?:const|function|class|interface|type|enum)\s+(\w+)/);
+                    if (exportMatch) {
+                        return `Exports '${exportMatch[1]}' from ${fileName}.`;
+                    }
+                    return `Angular code in ${fileName}.`;
                 }
-                return `Angular code in ${fileName}.`;
         }
     }
     extractLifecycleMethods(content) {
         const lifecycles = [
-            "ngOnInit",
-            "ngOnChanges",
-            "ngOnDestroy",
-            "ngAfterViewInit",
-            "ngAfterContentInit",
+            'ngOnInit',
+            'ngOnChanges',
+            'ngOnDestroy',
+            'ngAfterViewInit',
+            'ngAfterContentInit'
         ];
         const found = lifecycles.filter((method) => content.includes(method));
-        return found.length > 0 ? found.join(", ") : "";
+        return found.length > 0 ? found.join(', ') : '';
     }
     extractPublicMethods(content) {
         const methodMatches = content.match(/public\s+(\w+)\s*\(/g);
         if (!methodMatches || methodMatches.length === 0)
-            return "";
+            return '';
         const methods = methodMatches
             .slice(0, 3)
             .map((m) => m.match(/public\s+(\w+)/)?.[1])
             .filter(Boolean);
-        return methods.length > 0 ? `methods: ${methods.join(", ")}` : "";
+        return methods.length > 0 ? `methods: ${methods.join(', ')}` : '';
     }
     detectGuardType(content) {
-        if (content.includes("CanActivate"))
-            return "CanActivate";
-        if (content.includes("CanDeactivate"))
-            return "CanDeactivate";
-        if (content.includes("CanLoad"))
-            return "CanLoad";
-        if (content.includes("CanMatch"))
-            return "CanMatch";
-        return "route";
+        if (content.includes('CanActivate'))
+            return 'CanActivate';
+        if (content.includes('CanDeactivate'))
+            return 'CanDeactivate';
+        if (content.includes('CanLoad'))
+            return 'CanLoad';
+        if (content.includes('CanMatch'))
+            return 'CanMatch';
+        return 'route';
     }
     extractFirstComment(content) {
         const commentMatch = content.match(/\/\*\*\s*\n?\s*\*\s*(.+?)(?:\n|\*\/)/);
-        return commentMatch ? commentMatch[1].trim() : "";
+        return commentMatch ? commentMatch[1].trim() : '';
     }
     extractFirstLine(content) {
         const firstLine = content
-            .split("\n")
-            .find((line) => line.trim() && !line.trim().startsWith("import"));
-        return firstLine ? firstLine.trim().slice(0, 60) + "..." : "";
+            .split('\n')
+            .find((line) => line.trim() && !line.trim().startsWith('import'));
+        return firstLine ? firstLine.trim().slice(0, 60) + '...' : '';
     }
 }
 //# sourceMappingURL=index.js.map