codebase-context 1.7.0 → 1.8.0

package/README.md

@@ -1,6 +1,6 @@
 # codebase-context
 
-## Local-first second brain for AI Agents working on your codebase
+## Local-first second brain for AI agents working on your codebase
 
 [![npm version](https://img.shields.io/npm/v/codebase-context)](https://www.npmjs.com/package/codebase-context) [![license](https://img.shields.io/npm/l/codebase-context)](./LICENSE) [![node](https://img.shields.io/node/v/codebase-context)](./package.json)
 
@@ -16,11 +16,13 @@ Here's what codebase-context does:
 
 **Remembers across sessions** - Decisions, failures, workarounds that look wrong but exist for a reason - the battle scars that aren't in the comments. Recorded once, surfaced automatically so the agent doesn't "clean up" something you spent a week getting right. Conventional git commits (`refactor:`, `migrate:`, `fix:`) auto-extract into memory with zero effort. Stale memories decay and get flagged instead of blindly trusted.
 
-**Checks before editing** - Before editing something, you get a decision card showing whether there's enough evidence to proceed. If a symbol has four callers and only two appear in your search results, the card shows that coverage gap. If coverage is low, `whatWouldHelp` lists the specific searches to run before you touch anything. When code, team memories, and patterns contradict each other, it tells you to look deeper instead of guessing.
+**Checks before editing** - Before editing something, you get a decision card showing whether there's enough evidence to proceed. If a symbol has four callers (files that import or reference it) and only two appear in your search results, the card shows that coverage gap. If coverage is low, `whatWouldHelp` lists the specific searches to run before you touch anything. When code, team memories, and patterns contradict each other, it tells you to look deeper instead of guessing.
 
-One tool call returns all of it. Local-first - your code never leaves your machine.
+One tool call returns all of it. Local-first - your code never leaves your machine by default. Opt into `EMBEDDING_PROVIDER=openai` for cloud speed, but then code is sent externally.
 
-<!-- TODO: Add demo GIF: search_codebase("How does this app attach the auth token to outgoing API calls?") → AuthInterceptor top result + preflight + agent proceeds or asks -->
+The index auto-refreshes as you edit - a file watcher triggers incremental reindex in the background when the MCP server is running. No stale context between tool calls.
+
+<!-- TODO: Add demo GIF: search_codebase("How does this app attach the auth token to outgoing API calls?") -> AuthInterceptor top result + preflight + agent proceeds or asks -->
 <!-- ![Demo](./docs/assets/demo.gif) -->
 
 ## Quick Start
@@ -57,7 +59,7 @@ Add `.vscode/mcp.json` to your project root:
   "servers": {
     "codebase-context": {
       "command": "npx",
-      "args": ["-y", "codebase-context", "/path/to/your/project"] // Or "${workspaceFolder}"if your workspace is one project only
+      "args": ["-y", "codebase-context", "/path/to/your/project"] // Or "${workspaceFolder}" if your workspace is one project only
     }
   }
 }
@@ -93,9 +95,92 @@ Open Settings > MCP and add:
 }
 ```
 
-## Codex
+### Codex
+
+```bash
+codex mcp add codebase-context npx -y codebase-context "/path/to/your/project"
+```
+
+## New to this codebase?
+
+Three commands to get what usually takes a new developer weeks to piece together:
+
+```bash
+# What tech stack, architecture, and file count?
+npx -y codebase-context metadata
+
+# What does the team actually code like right now?
+npx -y codebase-context patterns
+
+# What team decisions were made (and why)?
+npx -y codebase-context memory list
+```
+
+This is also what your AI agent consumes automatically via MCP tools; the CLI is the human-readable version.
+
+### CLI preview
+
+```text
+$ npx -y codebase-context patterns
+┌─ Team Patterns ──────────────────────────────────────────────────────┐
+│                                                                      │
+│ UNIT TEST FRAMEWORK                                                  │
+│      USE: Vitest – 96% adoption                                      │
+│ alt  CAUTION: Jest – 4% minority pattern                             │
+│                                                                      │
+│ STATE MANAGEMENT                                                     │
+│      PREFER: RxJS – 63% adoption                                     │
+│ alt  Redux-style store – 25%                                         │
+│                                                                      │
+└──────────────────────────────────────────────────────────────────────┘
+```
+
+```text
+$ npx -y codebase-context search --query "file watcher" --intent edit --limit 1
+┌─ Search: "file watcher" ─── intent: edit ────────────────────────────┐
+│ Quality: ok (1.00)                                                   │
+│ Ready to edit: YES                                                   │
+│                                                                      │
+│ Best example: index.ts                                               │
+└──────────────────────────────────────────────────────────────────────┘
+```
 
-Run codex mcp add codebase-context npx -y codebase-context "/path/to/your/project"
+```text
+$ npx -y codebase-context metadata
+┌─ codebase-context [monorepo] ────────────────────────────────────────┐
+│                                                                      │
+│ Framework: Angular unknown   Architecture: mixed                     │
+│ 130 files · 24,211 lines · 1077 components                           │
+│                                                                      │
+│ Dependencies: @huggingface/transformers · @lancedb/lancedb ·         │
+│ @modelcontextprotocol/sdk · @typescript-eslint/typescript-estree ·   │
+│ chokidar · fuse.js (+14 more)                                        │
+│                                                                      │
+└──────────────────────────────────────────────────────────────────────┘
+```
+
+```text
+$ npx -y codebase-context refs --symbol "startFileWatcher"
+┌─ startFileWatcher ─── 11 references ─── static analysis ─────────────┐
+│                                                                      │
+│ startFileWatcher                                                     │
+│ │                                                                    │
+│ ├─ file-watcher.test.ts:5                                            │
+│ │   import { startFileWatcher } from '../src/core/file-watcher....   │
+│                                                                      │
+└──────────────────────────────────────────────────────────────────────┘
+```
+
+```text
+$ npx -y codebase-context cycles
+┌─ Circular Dependencies ──────────────────────────────────────────────┐
+│                                                                      │
+│ No cycles found  ·  98 files  ·  260 edges  ·  2.7 avg deps          │
+│                                                                      │
+└──────────────────────────────────────────────────────────────────────┘
+```
+
+See `docs/cli.md` for the full CLI gallery.
 
 ## What It Actually Does
 
@@ -122,7 +207,7 @@ This is where it all comes together. One call returns:
 - **Relationships** per result: `importedByCount` and `hasTests` (condensed) + **hints** (capped ranked callers, consumers, tests) — so you see suggested next reads and know what you haven't looked at yet
 - **Related memories**: up to 3 team decisions, gotchas, and failures matched to the query
 - **Search quality**: `ok` or `low_confidence` with confidence score and `hint` when low
-- **Preflight**: `ready` (boolean) with decision card when `intent="edit"|"refactor"|"migrate"`. Shows `nextAction` (if not ready), `warnings`, `patterns` (do/avoid), `bestExample`, `impact` (caller coverage), and `whatWouldHelp` (next steps). If search quality is low, `ready` is always `false`.
+- **Preflight**: `ready` (boolean) with decision card when `intent="edit"|"refactor"|"migrate"`. Shows `nextAction` (if not ready), `warnings`, `patterns` (do/avoid), `bestExample`, `impact` (import-graph coverage — how many files that import or reference the result are in your search), and `whatWouldHelp` (next steps). If search quality is low, `ready` is always `false`.
 
 Snippets are optional (`includeSnippets: true`). When enabled, snippets that have symbol metadata (e.g. from the Generic analyzer's AST chunking or Angular component chunks) start with a scope header so you know where the code lives (e.g. `// AuthService.getToken()` or `// SpotifyApiService`). Example:
 
@@ -135,43 +220,8 @@ getToken(): string {
 
 Default output is lean — if the agent wants code, it calls `read_file`.
 
-```json
-{
-  "searchQuality": { "status": "ok", "confidence": 0.72 },
-  "preflight": {
-    "ready": false,
-    "nextAction": "2 of 5 callers aren't in results — search for src/app.module.ts",
-    "patterns": {
-      "do": ["HttpInterceptorFn — 97%", "standalone components — 84%"],
-      "avoid": ["constructor injection — 3% (declining)"]
-    },
-    "bestExample": "src/auth/auth.interceptor.ts",
-    "impact": {
-      "coverage": "3/5 callers in results",
-      "files": ["src/app.module.ts", "src/boot.ts"]
-    },
-    "whatWouldHelp": [
-      "Search for src/app.module.ts to cover the main caller",
-      "Call get_team_patterns for auth/ injection patterns"
-    ]
-  },
-  "results": [
-    {
-      "file": "src/auth/auth.interceptor.ts:1-20",
-      "summary": "HTTP interceptor that attaches auth token to outgoing requests",
-      "score": 0.72,
-      "type": "service:core",
-      "trend": "Rising",
-      "relationships": { "importedByCount": 4, "hasTests": true },
-      "hints": {
-        "callers": ["src/app.module.ts", "src/boot.ts"],
-        "tests": ["src/auth/auth.interceptor.spec.ts"]
-      }
-    }
-  ],
-  "relatedMemories": ["Always use HttpInterceptorFn (0.97)"]
-}
-```
+For scripting and automation, every CLI command accepts `--json` for machine output (stdout = JSON; logs/errors go to stderr).
+See `docs/capabilities.md` for the field reference.
 
 Lean enough to fit on one screen. If search quality is low, preflight blocks edits instead of faking confidence.
 
@@ -194,18 +244,18 @@ Record a decision once. It surfaces automatically in search results and prefligh
 
 ### All Tools
 
-| Tool                           | What it does                                                                                |
-| ------------------------------ | ------------------------------------------------------------------------------------------- |
-| `search_codebase`              | Hybrid search + decision card. Pass `intent="edit"` to get `ready`, `nextAction`, patterns, caller coverage, and `whatWouldHelp`. |
-| `get_team_patterns`            | Pattern frequencies, golden files, conflict detection                                      |
+| Tool                           | What it does                                                                                                                                            |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `search_codebase`              | Hybrid search + decision card. Pass `intent="edit"` to get `ready`, `nextAction`, patterns, import-graph coverage, and `whatWouldHelp`.                 |
+| `get_team_patterns`            | Pattern frequencies, golden files, conflict detection                                                                                                   |
 | `get_symbol_references`        | Find concrete references to a symbol (usageCount + top snippets). `confidence: "syntactic"` = static/source-based only; no runtime or dynamic dispatch. |
-| `remember`                     | Record a convention, decision, gotcha, or failure                                          |
-| `get_memory`                   | Query team memory with confidence decay scoring                                            |
-| `get_codebase_metadata`        | Project structure, frameworks, dependencies                                                |
-| `get_style_guide`              | Style guide rules for the current project                                                  |
-| `detect_circular_dependencies` | Import cycles between files                                                                |
-| `refresh_index`                | Re-index (full or incremental) + extract git memories                                      |
-| `get_indexing_status`          | Progress and stats for the current index                                                   |
+| `remember`                     | Record a convention, decision, gotcha, or failure                                                                                                       |
+| `get_memory`                   | Query team memory with confidence decay scoring                                                                                                         |
+| `get_codebase_metadata`        | Project structure, frameworks, dependencies                                                                                                             |
+| `get_style_guide`              | Style guide rules for the current project                                                                                                               |
+| `detect_circular_dependencies` | Import cycles between files                                                                                                                             |
+| `refresh_index`                | Re-index (full or incremental) + extract git memories                                                                                                   |
+| `get_indexing_status`          | Progress and stats for the current index                                                                                                                |
 
 ## Evaluation Harness (`npm run eval`)
 
@@ -229,7 +279,7 @@ npm run eval -- tests/fixtures/codebases/eval-controlled tests/fixtures/codebase
 
 The retrieval pipeline is designed around one goal: give the agent the right context, not just any file that matches.
 
-- **Definition-first ranking** - for exact-name lookups (e.g. a symbol name), the file that *defines* the symbol ranks above files that only use it.
+- **Definition-first ranking** - for exact-name lookups (e.g. a symbol name), the file that _defines_ the symbol ranks above files that only use it.
 - **Intent classification** - knows whether "AuthService" is a name lookup or "how does auth work" is conceptual. Adjusts keyword/semantic weights accordingly.
 - **Hybrid fusion (RRF)** - combines keyword and semantic search using Reciprocal Rank Fusion instead of brittle score averaging.
 - **Query expansion** - conceptual queries automatically expand with domain-relevant terms (auth → login, token, session, guard).
@@ -254,12 +304,13 @@ Structured filters available: `framework`, `language`, `componentType`, `layer`
 
 ## Configuration
 
-| Variable                 | Default        | Description                                               |
-| ------------------------ | -------------- | --------------------------------------------------------- |
-| `EMBEDDING_PROVIDER`     | `transformers` | `openai` (fast, cloud) or `transformers` (local, private) |
-| `OPENAI_API_KEY`         | -              | Required only if using `openai` provider                  |
-| `CODEBASE_ROOT`          | -              | Project root (CLI arg takes precedence)                   |
-| `CODEBASE_CONTEXT_DEBUG` | -              | Set to `1` for verbose logging                            |
+| Variable                 | Default                    | Description                                                                                   |
+| ------------------------ | -------------------------- | --------------------------------------------------------------------------------------------- |
+| `EMBEDDING_PROVIDER`     | `transformers`             | `openai` (fast, cloud) or `transformers` (local, private)                                     |
+| `OPENAI_API_KEY`         | -                          | Required only if using `openai` provider                                                      |
+| `CODEBASE_ROOT`          | -                          | Project root (CLI arg takes precedence)                                                       |
+| `CODEBASE_CONTEXT_DEBUG` | -                          | Set to `1` for verbose logging                                                                |
+| `EMBEDDING_MODEL`        | `Xenova/bge-small-en-v1.5` | Local embedding model override (e.g. `onnx-community/granite-embedding-small-english-r2-ONNX` for Granite) |
 
 ## Performance
 
@@ -289,64 +340,72 @@ Structured filters available: `framework`, `language`, `componentType`, `layer`
 
 ## CLI Reference
 
-All MCP tools are available as CLI commands — no AI agent required. Useful for scripting, debugging, and CI workflows.
+All MCP tools are available as CLI commands — no AI agent required. Useful for onboarding, scripting, debugging, and CI workflows.
+For formatted examples and “money shots”, see `docs/cli.md`.
 
 Set `CODEBASE_ROOT` to your project root, or run from the project directory.
 
 ```bash
 # Search the indexed codebase
-npx codebase-context search --query "authentication middleware"
-npx codebase-context search --query "auth" --intent edit --limit 5
+npx -y codebase-context search --query "authentication middleware"
+npx -y codebase-context search --query "auth" --intent edit --limit 5
 
 # Project structure, frameworks, and dependencies
-npx codebase-context metadata
+npx -y codebase-context metadata
 
 # Index state and progress
-npx codebase-context status
+npx -y codebase-context status
 
 # Re-index the codebase
-npx codebase-context reindex
-npx codebase-context reindex --incremental --reason "added new service"
+npx -y codebase-context reindex
+npx -y codebase-context reindex --incremental --reason "added new service"
 
 # Style guide rules
-npx codebase-context style-guide
-npx codebase-context style-guide --query "naming" --category patterns
+npx -y codebase-context style-guide
+npx -y codebase-context style-guide --query "naming" --category patterns
 
 # Team patterns (DI, state, testing, etc.)
-npx codebase-context patterns
-npx codebase-context patterns --category testing
+npx -y codebase-context patterns
+npx -y codebase-context patterns --category testing
 
 # Symbol references
-npx codebase-context refs --symbol "UserService"
-npx codebase-context refs --symbol "handleLogin" --limit 20
+npx -y codebase-context refs --symbol "UserService"
+npx -y codebase-context refs --symbol "handleLogin" --limit 20
 
 # Circular dependency detection
-npx codebase-context cycles
-npx codebase-context cycles --scope src/features
+npx -y codebase-context cycles
+npx -y codebase-context cycles --scope src/features
 
 # Memory management
-npx codebase-context memory list
-npx codebase-context memory list --category conventions --type convention
-npx codebase-context memory list --query "auth" --json
-npx codebase-context memory add --type convention --category tooling --memory "Use pnpm, not npm" --reason "Workspace support and speed"
-npx codebase-context memory remove <id>
+npx -y codebase-context memory list
+npx -y codebase-context memory list --category conventions --type convention
+npx -y codebase-context memory list --query "auth" --json
+npx -y codebase-context memory add --type convention --category tooling --memory "Use pnpm, not npm" --reason "Workspace support and speed"
+npx -y codebase-context memory remove <id>
 ```
 
 All commands accept `--json` for raw JSON output suitable for piping and scripting.
 
-## Tip: Ensuring your AI Agent recalls memory:
+## What to add to your CLAUDE.md / AGENTS.md
 
-Add this to `.cursorrules`, `CLAUDE.md`, or `AGENTS.md`:
+Paste this into `.cursorrules`, `CLAUDE.md`, `AGENTS.md`, or wherever your AI reads project instructions:
 
-```
-## Codebase Context
+```markdown
+## Codebase Context (MCP)
+
+**Start of every task:** Call `get_memory` to load team conventions before writing any code.
 
-**At start of each task:** Call `get_memory` to load team conventions.
+**Before editing existing code:** Call `search_codebase` with `intent: "edit"`. If the preflight card says `ready: false`, read the listed files before touching anything.
 
-**When user says "remember this" or "record this":**
-- Call `remember` tool IMMEDIATELY before doing anything else.
+**Before writing new code:** Call `get_team_patterns` to check how the team handles DI, state, testing, and library wrappers — don't introduce a new pattern if one already exists.
+
+**When asked to "remember" or "record" something:** Call `remember` immediately, before doing anything else.
+
+**When adding imports that cross module boundaries:** Call `detect_circular_dependencies` with the relevant scope after adding the import.
 ```
 
+These are the behaviors that make the most difference day-to-day. Copy, trim what doesn't apply to your stack, and add it once.
+
 ## Links
 
 - [Motivation](./MOTIVATION.md) - Research and design rationale

package/dist/analyzers/angular/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/analyzers/angular/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,SAAS,EAKV,MAAM,sBAAsB,CAAC;AAS9B,qBAAa,eAAgB,YAAW,iBAAiB;IACvD,QAAQ,CAAC,IAAI,aAAa;IAC1B,QAAQ,CAAC,OAAO,WAAW;IAC3B,QAAQ,CAAC,mBAAmB,WAA8D;IAC1F,QAAQ,CAAC,QAAQ,OAAO;;IAQxB,OAAO,CAAC,eAAe,CAYrB;IAEF,OAAO,CAAC,uBAAuB,CAM7B;IAEF,OAAO,CAAC,qBAAqB,CAa3B;IAEF,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO;IAqBjD,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;YA0B3D,qBAAqB;IAuNnC;;OAEG;IACH,OAAO,CAAC,2BAA2B;YAYrB,uBAAuB;IAmHrC,OAAO,CAAC,wBAAwB;IAgChC,OAAO,CAAC,qBAAqB;IA2B7B,OAAO,CAAC,uBAAuB;IAqB/B,OAAO,CAAC,aAAa;IA4CrB,OAAO,CAAC,cAAc;YAyCR,mBAAmB;YAiCnB,gBAAgB;IAwB9B,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,cAAc;IA0DtB,OAAO,CAAC,oBAAoB;IA2BtB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA8JzE;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM;IA2FnC,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,gBAAgB;IAOxB,wFAAwF;IACxF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAqBtC;IAEF,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;CAGjE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/analyzers/angular/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,SAAS,EAMV,MAAM,sBAAsB,CAAC;AA6B9B,qBAAa,eAAgB,YAAW,iBAAiB;IACvD,QAAQ,CAAC,IAAI,aAAa;IAC1B,QAAQ,CAAC,OAAO,WAAW;IAC3B,QAAQ,CAAC,mBAAmB,WAA8D;IAC1F,QAAQ,CAAC,QAAQ,OAAO;;IAQxB,OAAO,CAAC,eAAe,CAYrB;IAEF,OAAO,CAAC,uBAAuB,CAM7B;IAEF,OAAO,CAAC,qBAAqB,CAa3B;IAEF,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO;IAqBjD,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;YA0B3D,qBAAqB;IA0NnC;;OAEG;IACH,OAAO,CAAC,2BAA2B;YAYrB,uBAAuB;IAyHrC,OAAO,CAAC,wBAAwB;IAiChC,OAAO,CAAC,qBAAqB;IA2B7B,OAAO,CAAC,uBAAuB;IA0B/B,OAAO,CAAC,aAAa;IAkErB,OAAO,CAAC,cAAc;YAoDR,mBAAmB;YAiCnB,gBAAgB;IAwB9B,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,cAAc;IA0DtB,OAAO,CAAC,oBAAoB;IA2BtB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgKzE;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM;IA6FnC,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,gBAAgB;IAOxB,wFAAwF;IACxF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAqBtC;IAEF,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;CAGjE"}

package/dist/analyzers/angular/index.js

@@ -3,7 +3,6 @@
  * Understands components, services, directives, pipes, modules, guards, interceptors, etc.
  * Detects state management patterns, architectural layers, and Angular-specific patterns
  */
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { promises as fs } from 'fs';
 import path from 'path';
 import { parse } from '@typescript-eslint/typescript-estree';
@@ -117,7 +116,8 @@ export class AngularAnalyzer {
                                 return 'default';
                             if (s.type === 'ImportNamespaceSpecifier')
                                 return '*';
-                            return s.imported?.name || s.local.name;
+                            const specifier = s;
+                            return specifier.imported.name || specifier.local.name;
                         }),
                         isDefault: node.specifiers.some((s) => s.type === 'ImportDefaultSpecifier'),
                         isDynamic: false,
@@ -290,11 +290,16 @@ export class AngularAnalyzer {
         return detected;
     }
     async extractAngularComponent(classNode, content) {
-        if (!classNode.decorators || classNode.decorators.length === 0) {
+        if (!classNode.id || !classNode.decorators || classNode.decorators.length === 0) {
             return null;
         }
         const decorator = classNode.decorators[0];
-        const decoratorName = decorator.expression.callee?.name || decorator.expression.name;
+        const expr = decorator.expression;
+        const decoratorName = expr.type === 'CallExpression' && expr.callee.type === 'Identifier'
+            ? expr.callee.name
+            : expr.type === 'Identifier'
+                ? expr.name
+                : '';
         let componentType;
         let angularType;
         // Determine Angular component type
@@ -403,23 +408,26 @@ export class AngularAnalyzer {
     extractDecoratorMetadata(decorator) {
         const metadata = {};
         try {
-            if (decorator.expression.arguments && decorator.expression.arguments[0]) {
+            if (decorator.expression.type === 'CallExpression' && decorator.expression.arguments[0]) {
                 const arg = decorator.expression.arguments[0];
                 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') {
-                                metadata[key] = prop.value.value;
-                            }
-                            else if (prop.value.type === 'ArrayExpression') {
-                                metadata[key] = prop.value.elements
-                                    .map((el) => (el.type === 'Literal' ? el.value : null))
-                                    .filter(Boolean);
-                            }
-                            else if (prop.value.type === 'Identifier') {
-                                metadata[key] = prop.value.name;
-                            }
+                        if (prop.type !== 'Property')
+                            continue;
+                        const keyNode = prop.key;
+                        const key = keyNode.name ?? String(keyNode.value ?? '');
+                        if (!key)
+                            continue;
+                        if (prop.value.type === 'Literal') {
+                            metadata[key] = prop.value.value;
+                        }
+                        else if (prop.value.type === 'ArrayExpression') {
+                            metadata[key] = prop.value.elements
+                                .map((el) => (el && el.type === 'Literal' ? el.value : null))
+                                .filter(Boolean);
+                        }
+                        else if (prop.value.type === 'Identifier') {
+                            metadata[key] = prop.value.name;
                         }
                     }
                 }
@@ -444,7 +452,7 @@ export class AngularAnalyzer {
         ];
         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 && member.key.type === 'Identifier') {
                     const methodName = member.key.name;
                     if (lifecycleHooks.includes(methodName)) {
                         hooks.push(methodName);
@@ -462,8 +470,13 @@ export class AngularAnalyzer {
                 if (member.type === 'MethodDefinition' && member.kind === 'constructor') {
                     if (member.value.params) {
                         for (const param of member.value.params) {
-                            if (param.typeAnnotation?.typeAnnotation?.typeName) {
-                                services.push(param.typeAnnotation.typeAnnotation.typeName.name);
+                            const typedParam = param;
+                            if (typedParam.typeAnnotation?.typeAnnotation?.type === 'TSTypeReference') {
+                                const typeRef = typedParam.typeAnnotation
+                                    .typeAnnotation;
+                                if (typeRef.typeName.type === 'Identifier') {
+                                    services.push(typeRef.typeName.name);
+                                }
                             }
                         }
                     }
@@ -479,26 +492,46 @@ export class AngularAnalyzer {
                 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');
-                        if (hasInput && member.key) {
+                        const hasInput = member.decorators.some((d) => {
+                            const expr = d.expression;
+                            return ((expr.type === 'CallExpression' &&
+                                expr.callee.type === 'Identifier' &&
+                                expr.callee.name === 'Input') ||
+                                (expr.type === 'Identifier' && expr.name === 'Input'));
+                        });
+                        if (hasInput && member.key && 'name' in member.key) {
                             inputs.push({
                                 name: member.key.name,
-                                type: member.typeAnnotation?.typeAnnotation?.type || 'any',
+                                type: member.typeAnnotation?.typeAnnotation?.type || 'unknown',
                                 style: 'decorator'
                             });
                         }
                     }
                     // Check for signal-based input() (Angular v17.1+)
-                    if (member.value && member.key) {
-                        const valueStr = member.value.type === 'CallExpression'
-                            ? member.value.callee?.name || member.value.callee?.object?.name
-                            : null;
+                    if (member.value &&
+                        member.key &&
+                        'name' in member.key &&
+                        member.value.type === 'CallExpression') {
+                        const callee = member.value.callee;
+                        let valueStr = null;
+                        let isRequired = false;
+                        if (callee.type === 'Identifier') {
+                            valueStr = callee.name;
+                        }
+                        else if (callee.type === 'MemberExpression') {
+                            if (callee.object.type === 'Identifier') {
+                                valueStr = callee.object.name;
+                            }
+                            if (callee.property.type === 'Identifier') {
+                                isRequired = callee.property.name === 'required';
+                            }
+                        }
                         if (valueStr === 'input') {
                             inputs.push({
                                 name: member.key.name,
                                 type: 'InputSignal',
                                 style: 'signal',
-                                required: member.value.callee?.property?.name === 'required'
+                                required: isRequired
                             });
                         }
                     }
@@ -514,8 +547,14 @@ export class AngularAnalyzer {
                 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');
-                        if (hasOutput && member.key) {
+                        const hasOutput = member.decorators.some((d) => {
+                            const expr = d.expression;
+                            return ((expr.type === 'CallExpression' &&
+                                expr.callee.type === 'Identifier' &&
+                                expr.callee.name === 'Output') ||
+                                (expr.type === 'Identifier' && expr.name === 'Output'));
+                        });
+                        if (hasOutput && member.key && 'name' in member.key) {
                             outputs.push({
                                 name: member.key.name,
                                 type: 'EventEmitter',
@@ -524,8 +563,12 @@ export class AngularAnalyzer {
                         }
                     }
                     // 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 (member.value &&
+                        member.key &&
+                        'name' in member.key &&
+                        member.value.type === 'CallExpression') {
+                        const callee = member.value.callee;
+                        const valueStr = callee.type === 'Identifier' ? callee.name : null;
                         if (valueStr === 'output') {
                             outputs.push({
                                 name: member.key.name,
@@ -769,11 +812,12 @@ export class AngularAnalyzer {
             if (Array.isArray(parsed)) {
                 return metadata;
             }
-            const chunks = parsed && Array.isArray(parsed.chunks) ? parsed.chunks : null;
+            const parsedObj = parsed;
+            const chunks = parsedObj && Array.isArray(parsedObj.chunks) ? parsedObj.chunks : null;
             if (Array.isArray(chunks) && chunks.length > 0) {
                 console.error(`Loading statistics from ${indexPath}: ${chunks.length} chunks`);
                 metadata.statistics.totalFiles = new Set(chunks.map((c) => c.filePath)).size;
-                metadata.statistics.totalLines = chunks.reduce((sum, c) => sum + (c.endLine - c.startLine + 1), 0);
+                metadata.statistics.totalLines = chunks.reduce((sum, c) => sum + ((c.endLine ?? 0) - (c.startLine ?? 0) + 1), 0);
                 // Count components by type
                 const componentCounts = {};
                 const layerCounts = {
@@ -820,8 +864,8 @@ export class AngularAnalyzer {
         switch (componentType) {
             case 'component': {
                 const selector = metadata?.selector || 'unknown';
-                const inputs = metadata?.inputs?.length || 0;
-                const outputs = metadata?.outputs?.length || 0;
+                const inputs = Array.isArray(metadata?.inputs) ? metadata.inputs.length : 0;
+                const outputs = Array.isArray(metadata?.outputs) ? metadata.outputs.length : 0;
                 const lifecycle = this.extractLifecycleMethods(content);
                 return `Angular component '${className}' (selector: ${selector})${lifecycle ? ` with ${lifecycle}` : ''}${inputs ? `, ${inputs} inputs` : ''}${outputs ? `, ${outputs} outputs` : ''}.`;
             }
@@ -843,8 +887,10 @@ export class AngularAnalyzer {
                 return `Angular pipe '${className}' (name: ${pipeName}) for data transformation.`;
             }
             case 'module': {
-                const imports = metadata?.imports?.length || 0;
-                const declarations = metadata?.declarations?.length || 0;
+                const imports = Array.isArray(metadata?.imports) ? metadata.imports.length : 0;
+                const declarations = Array.isArray(metadata?.declarations)
+                    ? metadata.declarations.length
+                    : 0;
                 return `Angular module '${className}' with ${declarations} declarations and ${imports} imports.`;
             }
             case 'interceptor':