@arcbridge/core 0.3.3 → 0.4.0

package/dist/index.js

@@ -41,7 +41,7 @@ var QualityScenariosFileSchema = z.object({
 var ServiceSchema = z2.object({
   name: z2.string().min(1),
   path: z2.string().default("."),
-  type: z2.enum(["nextjs", "react", "fastify", "express", "hono", "dotnet", "unity"]),
+  type: z2.enum(["nextjs", "react", "fastify", "express", "hono", "dotnet", "unity", "angular"]),
   tsconfig: z2.string().optional(),
   csproj: z2.string().optional()
 });
@@ -53,7 +53,8 @@ var ArcBridgeConfigSchema = z2.object({
     "react-vite",
     "api-service",
     "dotnet-webapi",
-    "unity-game"
+    "unity-game",
+    "angular-app"
   ]).default("nextjs-app-router"),
   services: z2.array(ServiceSchema).default([]),
   platforms: z2.array(z2.enum(["claude", "copilot", "gemini", "codex"])).default(["claude"]),
@@ -764,13 +765,45 @@ function configTemplate5(input) {
   };
 }
 
+// src/templates/config/angular-app.ts
+function configTemplate6(input) {
+  return {
+    schema_version: 1,
+    project_name: input.name,
+    project_type: input.template,
+    services: [{ name: "main", path: ".", type: "angular" }],
+    platforms: input.platforms,
+    quality_priorities: input.quality_priorities,
+    indexing: {
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist", ".angular", "coverage"],
+      default_mode: "fast",
+      csharp_indexer: "auto"
+    },
+    testing: {
+      test_command: "npx ng test --watch=false",
+      timeout_ms: 12e4
+    },
+    drift: {
+      ignore_paths: []
+    },
+    metrics: { auto_record: false },
+    sync: {
+      auto_detect_drift: true,
+      drift_severity_threshold: "warning",
+      propose_updates_on: "phase-complete"
+    }
+  };
+}
+
 // src/generators/config-generator.ts
 var configTemplates = {
   "nextjs-app-router": configTemplate,
   "react-vite": configTemplate2,
   "api-service": configTemplate3,
   "dotnet-webapi": configTemplate4,
-  "unity-game": configTemplate5
+  "unity-game": configTemplate5,
+  "angular-app": configTemplate6
 };
 function generateConfig(targetDir, input) {
   const templateFn = configTemplates[input.template] ?? configTemplate;
@@ -799,7 +832,7 @@ function introductionTemplate(input) {
 
 ## Requirements Overview
 
-${input.name} is a ${input.template === "nextjs-app-router" ? "Next.js application using the App Router" : input.template === "dotnet-webapi" ? "ASP.NET Core Web API" : input.template === "unity-game" ? "Unity game built with a code-heavy C# architecture" : "web application"}.
+${input.name} is a ${input.template === "nextjs-app-router" ? "Next.js application using the App Router" : input.template === "angular-app" ? "Angular application with standalone components" : input.template === "dotnet-webapi" ? "ASP.NET Core Web API" : input.template === "unity-game" ? "Unity game built with a code-heavy C# architecture" : "web application"}.
 
 ### Key Features
 
@@ -875,6 +908,10 @@ function techStack(template) {
       return `- **Engine:** Unity
 - **Language:** C#
 - **Runtime:** Mono / IL2CPP`;
+    case "angular-app":
+      return `- **Framework:** Angular
+- **Language:** TypeScript
+- **Runtime:** Node.js (build) / Browser (runtime)`;
     default:
       return `- **Framework:** Next.js (App Router)
 - **Language:** TypeScript
@@ -986,6 +1023,8 @@ function getEntrypoints(template, srcPrefix, appPrefix) {
       return [`${srcPrefix}index.ts`, `${srcPrefix}app.ts`, `${srcPrefix}server.ts`];
     case "unity-game":
       return ["Assets/Scripts/Core/GameManager.cs"];
+    case "angular-app":
+      return [`${srcPrefix}main.ts`, `${srcPrefix}app/app.component.ts`, `${srcPrefix}app/app.routes.ts`];
     default:
       return [`${srcPrefix}index.ts`];
   }
@@ -995,7 +1034,7 @@ function getEntrypoints(template, srcPrefix, appPrefix) {
 function buildingBlocksTemplate(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const layout = detectProjectLayout(input.projectRoot, input.template);
-  const defaultBlocks = input.template === "dotnet-webapi" ? buildDotnetBlocks(input) : input.template === "unity-game" ? buildUnityBlocks() : buildJsBlocks(input, layout);
+  const defaultBlocks = input.template === "dotnet-webapi" ? buildDotnetBlocks(input) : input.template === "unity-game" ? buildUnityBlocks() : input.template === "angular-app" ? buildAngularBlocks(layout) : buildJsBlocks(input, layout);
   function buildJsBlocks(inp, lt) {
     const src = lt.srcPrefix;
     const entries = lt.entrypoints;
@@ -1283,6 +1322,77 @@ function buildingBlocksTemplate(input) {
       }
     ];
   }
+  function buildAngularBlocks(lt) {
+    const src = lt.srcPrefix;
+    return [
+      {
+        id: "app-shell",
+        name: "App Shell",
+        level: 1,
+        code_paths: [`${src}main.ts`, `${src}app/app.component.ts`, `${src}app/app.config.ts`, `${src}app/app.routes.ts`],
+        interfaces: [],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "Application bootstrap, root component, top-level routing and providers",
+        service: "main"
+      },
+      {
+        id: "core-services",
+        name: "Core Services",
+        level: 1,
+        code_paths: [`${src}app/core/`],
+        interfaces: [],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "Singleton services, guards, interceptors, and app-wide infrastructure",
+        service: "main"
+      },
+      {
+        id: "shared-components",
+        name: "Shared Components",
+        level: 1,
+        code_paths: [`${src}app/shared/`],
+        interfaces: [],
+        quality_scenarios: ["A11Y-01"],
+        adrs: [],
+        responsibility: "Reusable components, directives, and pipes shared across features",
+        service: "main"
+      },
+      {
+        id: "feature-modules",
+        name: "Feature Modules",
+        level: 1,
+        code_paths: [`${src}app/features/`],
+        interfaces: ["core-services", "shared-components"],
+        quality_scenarios: ["PERF-05"],
+        adrs: [],
+        responsibility: "Self-contained feature areas with own routes, components, and services",
+        service: "main"
+      },
+      {
+        id: "models",
+        name: "Models & Types",
+        level: 1,
+        code_paths: [`${src}app/models/`],
+        interfaces: [],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "Shared interfaces, types, enums, and DTOs",
+        service: "main"
+      },
+      {
+        id: "api-client",
+        name: "API Client",
+        level: 1,
+        code_paths: [`${src}app/core/http/`, `${src}app/core/services/`],
+        interfaces: [],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "HTTP client layer, interceptors, and API service abstractions",
+        service: "main"
+      }
+    ];
+  }
   return {
     frontmatter: {
       section: "building-blocks",
@@ -1317,6 +1427,12 @@ Client \u2192 Kestrel \u2192 Middleware Pipeline \u2192 Controller / Endpoint
 Client \u2192 HTTP Server \u2192 Middleware \u2192 Route Handler
                                   \u2192 Services
                                   \u2192 Database / External APIs
+\`\`\``;
+    case "angular-app":
+      return `\`\`\`
+Browser \u2192 Angular Router \u2192 Feature Component (lazy-loaded)
+                         \u2192 Services (DI)
+                         \u2192 HTTP Interceptors \u2192 API
 \`\`\``;
     case "unity-game":
       return `\`\`\`
@@ -1369,7 +1485,12 @@ function deploymentTemplate(input) {
 
 ### Deployment Options
 
-${input.template === "dotnet-webapi" ? `| Platform | Description | Notes |
+${input.template === "angular-app" ? `| Platform | Description | Notes |
+|----------|-------------|-------|
+| Vercel / Netlify | Static hosting | For SSG or prerendered apps |
+| Firebase Hosting | Google Cloud | Integrated with Angular Fire |
+| Docker | Container-based | For self-hosted environments |
+| Cloud Run / App Engine | Google Cloud PaaS | For SSR with Angular Universal |` : input.template === "dotnet-webapi" ? `| Platform | Description | Notes |
 |----------|-------------|-------|
 | Azure App Service | Managed PaaS for .NET | Recommended for ASP.NET Core |
 | Docker / Kubernetes | Container-based | For self-hosted or multi-cloud |
@@ -1406,6 +1527,8 @@ function firstAdrTemplate(input) {
       return apiServiceAdr(input, now);
     case "unity-game":
       return unityAdr(input, now);
+    case "angular-app":
+      return angularAdr(input, now);
     default:
       return nextjsAdr(input, now);
   }
@@ -1510,6 +1633,44 @@ Use a Node.js HTTP framework (Express, Fastify, or Hono) as the API service foun
 `
   };
 }
+function angularAdr(input, date) {
+  const { srcPrefix } = detectProjectLayout(input.projectRoot, input.template);
+  return {
+    filename: "001-angular-standalone.md",
+    frontmatter: {
+      id: "001-angular-standalone",
+      title: "Use Angular with Standalone Components",
+      status: "accepted",
+      date,
+      affected_blocks: ["app-shell", "feature-modules"],
+      affected_files: [srcPrefix || "./"],
+      quality_scenarios: []
+    },
+    body: `# ADR-001: Use Angular with Standalone Components
+
+## Context
+
+${input.name} needs a modern, opinionated frontend framework with strong TypeScript support, dependency injection, and a structured approach to building large applications.
+
+## Decision
+
+Use Angular with standalone components (default since Angular v17). Use the signals API for reactive state management and functional guards/resolvers for routing.
+
+## Consequences
+
+- **Positive:** Strong TypeScript integration with decorators and DI
+- **Positive:** Standalone components simplify the module system and improve tree-shaking
+- **Positive:** Signals provide fine-grained reactivity without Zone.js overhead
+- **Positive:** Opinionated structure reduces architectural decision fatigue
+- **Negative:** Steeper learning curve compared to lighter frameworks
+- **Negative:** Larger initial bundle size (mitigated by lazy loading)
+
+## Current Limitations
+
+The TypeScript indexer fully indexes Angular symbols, dependencies, services, and \`@Component\` declarations. The \`arcbridge_get_component_graph\` tool lists detected Angular components with their selectors and imports, but **template-based relationship analysis** (which component renders which via template selectors) is not yet implemented. Component listing works; hierarchy tracking is a planned enhancement.
+`
+  };
+}
 function unityAdr(input, date) {
   return {
     filename: "001-unity-code-heavy.md",
@@ -1989,9 +2150,122 @@ var UNITY_GAME_SCENARIOS = {
     }
   ]
 };
+var ANGULAR_SCENARIOS = {
+  security: [
+    {
+      id: "SEC-02",
+      name: "No secrets in client bundles",
+      category: "security",
+      priority: "must",
+      scenario: "Production build output is analyzed",
+      expected: "No API keys, tokens, or secrets found in client-side JavaScript bundles",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "automatic",
+      status: "untested"
+    },
+    {
+      id: "SEC-04",
+      name: "No bypassSecurityTrust without review",
+      category: "security",
+      priority: "should",
+      scenario: "Source code is scanned for DomSanitizer bypass calls",
+      expected: "All bypassSecurityTrust* calls have a documented justification in an ADR or code comment",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "semi-automatic",
+      status: "untested"
+    }
+  ],
+  performance: [
+    {
+      id: "PERF-01",
+      name: "Initial page load under 3s",
+      category: "performance",
+      priority: "should",
+      scenario: "User loads the landing page on a 3G connection",
+      expected: "Largest Contentful Paint (LCP) is under 3 seconds",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-03",
+      name: "Main bundle under 200KB gzipped",
+      category: "performance",
+      priority: "should",
+      scenario: "Production build is analyzed",
+      expected: "Main JavaScript bundle is under 200KB gzipped",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-04",
+      name: "OnPush or signal-based change detection",
+      category: "performance",
+      priority: "should",
+      scenario: "Components are reviewed for change detection strategy",
+      expected: "All components use OnPush strategy or signal-based inputs \u2014 no default change detection",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-05",
+      name: "Lazy loading on feature routes",
+      category: "performance",
+      priority: "must",
+      scenario: "Application routes are analyzed",
+      expected: "All feature routes use loadComponent or loadChildren for lazy loading",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["feature-modules"],
+      verification: "automatic",
+      status: "untested"
+    }
+  ],
+  accessibility: [
+    {
+      id: "A11Y-01",
+      name: "WCAG 2.1 AA compliance",
+      category: "accessibility",
+      priority: "should",
+      scenario: "All pages are audited with axe-core",
+      expected: "No critical or serious accessibility violations",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "A11Y-02",
+      name: "Keyboard navigation",
+      category: "accessibility",
+      priority: "should",
+      scenario: "User navigates the entire application using only keyboard",
+      expected: "All interactive elements are reachable and operable via keyboard",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "manual",
+      status: "untested"
+    }
+  ]
+};
 var TEMPLATE_SCENARIOS = {
   "nextjs-app-router": FRONTEND_SCENARIOS,
   "react-vite": FRONTEND_SCENARIOS,
+  "angular-app": ANGULAR_SCENARIOS,
   "api-service": API_SCENARIOS,
   "dotnet-webapi": DOTNET_SCENARIOS,
   "unity-game": UNITY_GAME_SCENARIOS
@@ -2297,7 +2571,7 @@ function unityConcepts() {
 }
 function crosscuttingTemplate(input) {
   const isDotnet = input.template === "dotnet-webapi";
-  const isFrontend = input.template === "nextjs-app-router" || input.template === "react-vite";
+  const isFrontend = input.template === "nextjs-app-router" || input.template === "react-vite" || input.template === "angular-app";
   const isUnity = input.template === "unity-game";
   let concepts;
   if (isDotnet) {
@@ -3492,13 +3766,184 @@ function phaseTasksTemplate5(_input, phaseId) {
   return tasksByPhase[phaseId] ?? null;
 }
 
+// src/templates/phases/angular-app.ts
+function phasePlanTemplate6(_input) {
+  const phases = [
+    {
+      id: "phase-0-setup",
+      name: "Project Setup",
+      phase_number: 0,
+      status: "planned",
+      description: "Initialize Angular project, configure strict TypeScript, set up tooling and testing infrastructure",
+      gate_requirements: [
+        "Angular project builds and serves without errors",
+        "Strict TypeScript configuration enabled",
+        "Testing infrastructure configured (Vitest or Karma)",
+        "Linting and formatting in place"
+      ]
+    },
+    {
+      id: "phase-1-foundation",
+      name: "Foundation",
+      phase_number: 1,
+      status: "planned",
+      description: "App shell, routing with lazy loading, shared component library, core services (HTTP interceptor, auth guard)",
+      gate_requirements: [
+        "App shell with routing configured",
+        "At least one lazy-loaded feature route",
+        "HTTP interceptor for API calls",
+        "Shared component library started",
+        "Quality scenario PERF-05 (lazy loading) verified"
+      ]
+    },
+    {
+      id: "phase-2-features",
+      name: "Core Features",
+      phase_number: 2,
+      status: "planned",
+      description: "Feature implementation, state management with signals or NgRx, integration tests",
+      gate_requirements: [
+        "Core features complete and functional",
+        "State management approach established",
+        "Integration tests cover key workflows",
+        "All feature routes lazy-loaded"
+      ]
+    },
+    {
+      id: "phase-3-polish",
+      name: "Polish & Launch",
+      phase_number: 3,
+      status: "planned",
+      description: "Performance audit (bundle size, change detection), accessibility, deployment configuration",
+      gate_requirements: [
+        "All quality scenarios passing",
+        "Bundle size within budget",
+        "Accessibility audit complete",
+        "Production build and deployment successful"
+      ]
+    }
+  ];
+  return { schema_version: 1, phases };
+}
+function phaseTasksTemplate6(_input, phaseId) {
+  const tasksByPhase = {
+    "phase-0-setup": {
+      schema_version: 1,
+      phase_id: "phase-0-setup",
+      tasks: [
+        {
+          id: "task-0.1-init-project",
+          title: "Initialize Angular project with strict configuration",
+          status: "todo",
+          building_block: "app-shell",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "Angular CLI project created with strict mode",
+            "Standalone components enabled (default in Angular 17+)",
+            "TypeScript strict mode enforced"
+          ]
+        },
+        {
+          id: "task-0.2-routing",
+          title: "Set up routing with lazy loading",
+          status: "todo",
+          building_block: "app-shell",
+          quality_scenarios: ["PERF-05"],
+          acceptance_criteria: [
+            "App routes defined in app.routes.ts",
+            "At least one feature route uses loadComponent or loadChildren",
+            "Route guards and resolvers use functional approach"
+          ]
+        },
+        {
+          id: "task-0.3-core-services",
+          title: "Set up core services and HTTP interceptor",
+          status: "todo",
+          building_block: "core-services",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "HTTP interceptor for API base URL and error handling",
+            "Core services provided in root",
+            "Environment configuration set up"
+          ]
+        },
+        {
+          id: "task-0.4-testing",
+          title: "Set up testing infrastructure",
+          status: "todo",
+          quality_scenarios: ["MAINT-02"],
+          acceptance_criteria: [
+            "Unit test framework configured (Vitest or Karma/Jasmine)",
+            "First component test passes",
+            "Test coverage reporting enabled"
+          ]
+        }
+      ]
+    },
+    "phase-1-foundation": {
+      schema_version: 1,
+      phase_id: "phase-1-foundation",
+      tasks: [
+        {
+          id: "task-1.1-shared-components",
+          title: "Build shared component library",
+          status: "todo",
+          building_block: "shared-components",
+          quality_scenarios: ["A11Y-01"],
+          acceptance_criteria: [
+            "Reusable UI components in shared/ directory",
+            "Components use OnPush change detection or signals",
+            "Components follow accessibility guidelines"
+          ]
+        },
+        {
+          id: "task-1.2-auth",
+          title: "Implement authentication and route guards",
+          status: "todo",
+          building_block: "core-services",
+          quality_scenarios: ["SEC-01"],
+          acceptance_criteria: [
+            "Auth service with login/logout/token management",
+            "Functional route guard protecting private routes",
+            "Auth interceptor attaching tokens to API requests"
+          ]
+        },
+        {
+          id: "task-1.3-api-client",
+          title: "Set up API client layer",
+          status: "todo",
+          building_block: "api-client",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "Typed API service methods for backend endpoints",
+            "Error handling and retry logic",
+            "Loading/error state management"
+          ]
+        },
+        {
+          id: "task-1.4-document-decisions",
+          title: "Document architectural decisions as ADRs",
+          status: "todo",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "ADR for each significant architecture/pattern choice",
+            "ADRs linked to affected building blocks and code paths"
+          ]
+        }
+      ]
+    }
+  };
+  return tasksByPhase[phaseId] ?? null;
+}
+
 // src/generators/plan-generator.ts
 var planTemplates = {
   "nextjs-app-router": { plan: phasePlanTemplate, tasks: phaseTasksTemplate },
   "react-vite": { plan: phasePlanTemplate2, tasks: phaseTasksTemplate2 },
   "api-service": { plan: phasePlanTemplate3, tasks: phaseTasksTemplate3 },
   "dotnet-webapi": { plan: phasePlanTemplate4, tasks: phaseTasksTemplate4 },
-  "unity-game": { plan: phasePlanTemplate5, tasks: phaseTasksTemplate5 }
+  "unity-game": { plan: phasePlanTemplate5, tasks: phaseTasksTemplate5 },
+  "angular-app": { plan: phasePlanTemplate6, tasks: phaseTasksTemplate6 }
 };
 function generatePlan(targetDir, input) {
   const planDir = join5(targetDir, ".arcbridge", "plan");
@@ -4172,7 +4617,7 @@ You cannot see screenshots, but you CAN reason about UI quality through code:
 }
 
 // src/generators/agent-generator.ts
-var UI_TEMPLATES = /* @__PURE__ */ new Set(["nextjs-app-router", "react-vite", "unity-game"]);
+var UI_TEMPLATES = /* @__PURE__ */ new Set(["nextjs-app-router", "react-vite", "angular-app", "unity-game"]);
 function writeAgentRole(dir, role) {
   const { system_prompt, ...frontmatter } = role;
   const content = matter2.stringify(system_prompt, frontmatter);
@@ -4717,11 +5162,16 @@ function extractSymbols(sourceFile, checker, relativePath, contentHash) {
     }
     if (ts3.isClassDeclaration(node) && node.name) {
       const name = node.name.text;
+      const decorators = typeof ts3.canHaveDecorators === "function" && typeof ts3.getDecorators === "function" && ts3.canHaveDecorators(node) ? ts3.getDecorators(node) ?? [] : node.modifiers?.filter(ts3.isDecorator) ?? [];
+      const hasComponentDecorator = decorators.some(
+        (d) => ts3.isCallExpression(d.expression) && ts3.isIdentifier(d.expression.expression) && d.expression.expression.text === "Component"
+      );
+      const kind = hasComponentDecorator ? "component" : "class";
       symbols.push({
-        id: makeId(name, "class"),
+        id: makeId(name, kind),
         name,
         qualifiedName: name,
-        kind: "class",
+        kind,
         filePath: relativePath,
         ...getLocation(node),
         signature: null,
@@ -5300,6 +5750,70 @@ function analyzeComponents(sourceFiles, checker, projectRoot, db, allClient = fa
           });
         }
       }
+      if (ts5.isClassDeclaration(node) && node.name) {
+        const decorators = typeof ts5.canHaveDecorators === "function" && typeof ts5.getDecorators === "function" && ts5.canHaveDecorators(node) ? ts5.getDecorators(node) ?? [] : node.modifiers?.filter(ts5.isDecorator) ?? [];
+        const componentDecorator = decorators.find(
+          (decorator) => ts5.isCallExpression(decorator.expression) && ts5.isIdentifier(decorator.expression.expression) && decorator.expression.expression.text === "Component"
+        );
+        if (componentDecorator && ts5.isCallExpression(componentDecorator.expression)) {
+          const name = node.name.text;
+          const symbolId = `${relPath}::${name}#component`;
+          let propsType = null;
+          const metaArg = componentDecorator.expression.arguments[0];
+          if (metaArg && ts5.isObjectLiteralExpression(metaArg)) {
+            const selectorProp = metaArg.properties.find(
+              (p) => ts5.isPropertyAssignment(p) && ts5.isIdentifier(p.name) && p.name.text === "selector"
+            );
+            if (selectorProp && ts5.isStringLiteral(selectorProp.initializer)) {
+              propsType = `selector: ${selectorProp.initializer.text}`;
+            }
+          }
+          let hasState = false;
+          if (node.members) {
+            for (const member of node.members) {
+              if (ts5.isPropertyDeclaration(member) && member.initializer) {
+                const init = ts5.isParenthesizedExpression(member.initializer) ? member.initializer.expression : member.initializer;
+                if (ts5.isCallExpression(init)) {
+                  const callee = init.expression;
+                  const calleeName = ts5.isIdentifier(callee) ? callee.text : ts5.isPropertyAccessExpression(callee) ? callee.name.text : null;
+                  if (calleeName === "signal" || calleeName === "computed") {
+                    hasState = true;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+          if (metaArg && ts5.isObjectLiteralExpression(metaArg)) {
+            const importsProp = metaArg.properties.find(
+              (p) => ts5.isPropertyAssignment(p) && ts5.isIdentifier(p.name) && p.name.text === "imports"
+            );
+            if (importsProp && ts5.isArrayLiteralExpression(importsProp.initializer)) {
+              const importNames = [];
+              for (const el of importsProp.initializer.elements) {
+                if (ts5.isIdentifier(el)) {
+                  importNames.push(el.text);
+                }
+              }
+              if (importNames.length > 0) {
+                propsType = propsType ? `${propsType} | imports: ${importNames.join(", ")}` : `imports: ${importNames.join(", ")}`;
+              }
+            }
+          }
+          components.push({
+            symbolId,
+            isClient: true,
+            // Angular components are always client-side
+            isServerAction: false,
+            hasState,
+            contextProviders: [],
+            // Angular uses DI, not context
+            contextConsumers: [],
+            // Not applicable for Angular
+            propsType
+          });
+        }
+      }
     });
   }
   writeComponents(db, components);
@@ -6950,7 +7464,7 @@ function indexTypeScriptProject(db, options) {
   });
   db.prepare("DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ?)").run(service);
   writeDependencies(db, allDeps);
-  const CLIENT_ONLY_TEMPLATES = /* @__PURE__ */ new Set(["react-vite"]);
+  const CLIENT_ONLY_TEMPLATES = /* @__PURE__ */ new Set(["react-vite", "angular-app"]);
   const projectType = db.prepare("SELECT value FROM arcbridge_meta WHERE key = 'project_type'").get()?.value;
   const allClient = projectType ? CLIENT_ONLY_TEMPLATES.has(projectType) : false;
   const componentsAnalyzed = analyzeComponents(sourceFiles, checker, projectRoot, db, allClient);
@@ -6989,6 +7503,14 @@ var FRAMEWORK_IGNORES = {
   ],
   "react-vite": ["src/main.", "src/App.", "vite.config"],
   "api-service": ["src/index.", "src/app.", "src/server."],
+  "angular-app": [
+    ".angular/",
+    "src/environments/",
+    "src/main.ts",
+    "src/index.html",
+    "src/styles.",
+    "angular.json"
+  ],
   "dotnet-webapi": [
     "Program.",
     "Startup.",