@orsetra/camel-pom-gen 1.0.0

package/src/generator/pom.ts

@@ -0,0 +1,221 @@
+/**
+ * pom.xml serializer — mirrors pkg/util/maven/maven_project.go → MarshalBytes.
+ *
+ * Produces the same pom.xml structure as the Camel K operator:
+ *   - properties (sourceEncoding, jar type, outputTimestamp)
+ *   - dependencyManagement (BOMs)
+ *   - dependencies
+ *   - repositories / pluginRepositories
+ *   - build/plugins (quarkus-maven-plugin)
+ *   - profiles (JIB)
+ */
+import type { MavenDependency, MavenPlugin, MavenProfile, MavenProject, MavenRepository } from '../dependencies/types'
+
+const POM_NS = 'http://maven.apache.org/POM/4.0.0'
+const XSI    = 'http://www.w3.org/2001/XMLSchema-instance'
+const XSD    = 'http://maven.apache.org/xsd/maven-4.0.0.xsd'
+
+// ── XML helpers ───────────────────────────────────────────────────────────────
+
+function esc(s: string): string {
+  return s
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+}
+
+function tag(name: string, value: string, indent: string): string {
+  return `${indent}<${name}>${esc(value)}</${name}>\n`
+}
+
+// ── Dependency block ──────────────────────────────────────────────────────────
+
+function depBlock(dep: MavenDependency, indent: string, exclusions?: { groupId: string; artifactId: string }[]): string {
+  let s = `${indent}<dependency>\n`
+  s += tag('groupId',    dep.groupId,    indent + '  ')
+  s += tag('artifactId', dep.artifactId, indent + '  ')
+  if (dep.version)     s += tag('version',    dep.version,    indent + '  ')
+  if (dep.scope)       s += tag('scope',      dep.scope,      indent + '  ')
+  if (dep.type)        s += tag('type',       dep.type,       indent + '  ')
+  if (dep.classifier)  s += tag('classifier', dep.classifier, indent + '  ')
+  if (exclusions && exclusions.length > 0) {
+    s += `${indent}  <exclusions>\n`
+    for (const ex of exclusions) {
+      s += `${indent}    <exclusion>\n`
+      s += tag('groupId',    ex.groupId,    indent + '      ')
+      s += tag('artifactId', ex.artifactId, indent + '      ')
+      s += `${indent}    </exclusion>\n`
+    }
+    s += `${indent}  </exclusions>\n`
+  }
+  s += `${indent}</dependency>\n`
+  return s
+}
+
+// ── Repository block ──────────────────────────────────────────────────────────
+
+function repoBlock(repo: MavenRepository, indent: string): string {
+  let s = `${indent}<repository>\n`
+  s += tag('id',  repo.id,  indent + '  ')
+  if (repo.name) s += tag('name', repo.name, indent + '  ')
+  s += tag('url', repo.url, indent + '  ')
+  if (repo.releases) {
+    s += `${indent}  <releases>\n`
+    s += tag('enabled', String(repo.releases.enabled), indent + '    ')
+    if (repo.releases.checksumPolicy) s += tag('checksumPolicy', repo.releases.checksumPolicy, indent + '    ')
+    s += `${indent}  </releases>\n`
+  }
+  if (repo.snapshots) {
+    s += `${indent}  <snapshots>\n`
+    s += tag('enabled', String(repo.snapshots.enabled), indent + '    ')
+    if (repo.snapshots.checksumPolicy) s += tag('checksumPolicy', repo.snapshots.checksumPolicy, indent + '    ')
+    s += `${indent}  </snapshots>\n`
+  }
+  s += `${indent}</repository>\n`
+  return s
+}
+
+// ── Plugin block ──────────────────────────────────────────────────────────────
+
+function pluginBlock(plugin: MavenPlugin, indent: string): string {
+  let s = `${indent}<plugin>\n`
+  s += tag('groupId',    plugin.groupId,    indent + '  ')
+  s += tag('artifactId', plugin.artifactId, indent + '  ')
+  if (plugin.version)    s += tag('version', plugin.version, indent + '  ')
+  if (plugin.extensions) s += `${indent}  <extensions>true</extensions>\n`
+  if (plugin.executions && plugin.executions.length > 0) {
+    s += `${indent}  <executions>\n`
+    for (const exec of plugin.executions) {
+      s += `${indent}    <execution>\n`
+      if (exec.id)    s += tag('id',    exec.id,    indent + '      ')
+      if (exec.phase) s += tag('phase', exec.phase, indent + '      ')
+      if (exec.goals.length > 0) {
+        s += `${indent}      <goals>\n`
+        for (const goal of exec.goals) s += tag('goal', goal, indent + '        ')
+        s += `${indent}      </goals>\n`
+      }
+      s += `${indent}    </execution>\n`
+    }
+    s += `${indent}  </executions>\n`
+  }
+  if (plugin.dependencies && plugin.dependencies.length > 0) {
+    s += `${indent}  <dependencies>\n`
+    for (const dep of plugin.dependencies) s += depBlock(dep, indent + '    ')
+    s += `${indent}  </dependencies>\n`
+  }
+  if (plugin.configurationXml) {
+    s += `${indent}  <configuration>\n${plugin.configurationXml}\n${indent}  </configuration>\n`
+  }
+  s += `${indent}</plugin>\n`
+  return s
+}
+
+// ── Profile block ─────────────────────────────────────────────────────────────
+
+function profileBlock(profile: MavenProfile): string {
+  // If a raw XML string is provided, inject it verbatim (used for JIB profile)
+  if (profile.rawXml) return profile.rawXml + '\n'
+
+  let s = `    <profile>\n`
+  s += tag('id', profile.id, '      ')
+  if (typeof profile.activeByDefault === 'boolean') {
+    s += `      <activation>\n`
+    s += tag('activeByDefault', String(profile.activeByDefault), '        ')
+    s += `      </activation>\n`
+  }
+  if (profile.plugins && profile.plugins.length > 0) {
+    s += `      <build>\n`
+    s += `        <plugins>\n`
+    for (const p of profile.plugins) s += pluginBlock(p, '          ')
+    s += `        </plugins>\n`
+    s += `      </build>\n`
+  }
+  s += `    </profile>\n`
+  return s
+}
+
+// ── Main serializer ───────────────────────────────────────────────────────────
+
+export function serializePom(project: MavenProject): string {
+  let xml = `<?xml version="1.0" encoding="UTF-8"?>\n`
+  xml += `<project xmlns="${POM_NS}"\n`
+  xml += `         xmlns:xsi="${XSI}"\n`
+  xml += `         xsi:schemaLocation="${POM_NS} ${XSD}">\n`
+  xml += `  <modelVersion>4.0.0</modelVersion>\n\n`
+  xml += tag('groupId',    project.groupId,    '  ')
+  xml += tag('artifactId', project.artifactId, '  ')
+  xml += tag('version',    project.version,    '  ')
+  xml += '\n'
+
+  // ── properties ──────────────────────────────────────────────────────────
+  const props = Object.entries(project.properties)
+  if (props.length > 0) {
+    xml += `  <properties>\n`
+    for (const [k, v] of props) xml += tag(k, v, '    ')
+    xml += `  </properties>\n\n`
+  }
+
+  // ── dependencyManagement (BOMs) ─────────────────────────────────────────
+  if (project.boms.length > 0) {
+    xml += `  <dependencyManagement>\n    <dependencies>\n`
+    for (const bom of project.boms) {
+      xml += `      <dependency>\n`
+      xml += tag('groupId',    bom.groupId,    '        ')
+      xml += tag('artifactId', bom.artifactId, '        ')
+      xml += tag('version',    bom.version,    '        ')
+      xml += tag('type',       'pom',          '        ')
+      xml += tag('scope',      'import',       '        ')
+      xml += `      </dependency>\n`
+    }
+    xml += `    </dependencies>\n  </dependencyManagement>\n\n`
+  }
+
+  // ── dependencies ────────────────────────────────────────────────────────
+  if (project.dependencies.length > 0) {
+    xml += `  <dependencies>\n`
+    for (const dep of project.dependencies) {
+      const key = `${dep.groupId}:${dep.artifactId}`
+      xml += depBlock(dep, '    ', project.exclusions.get(key))
+    }
+    xml += `  </dependencies>\n\n`
+  }
+
+  // ── repositories ────────────────────────────────────────────────────────
+  if (project.repositories.length > 0) {
+    xml += `  <repositories>\n`
+    for (const r of project.repositories) xml += repoBlock(r, '    ')
+    xml += `  </repositories>\n\n`
+  }
+
+  // ── pluginRepositories (mirrors repositories) ────────────────────────────
+  const pluginRepos = project.pluginRepositories.length > 0
+    ? project.pluginRepositories
+    : project.repositories  // operator copies repositories → pluginRepositories
+  if (pluginRepos.length > 0) {
+    xml += `  <pluginRepositories>\n`
+    for (const r of pluginRepos) {
+      // <pluginRepositories> uses <pluginRepository> element name
+      const block = repoBlock(r, '    ').replace('<repository>', '<pluginRepository>').replace('</repository>', '</pluginRepository>')
+      xml += block
+    }
+    xml += `  </pluginRepositories>\n\n`
+  }
+
+  // ── build / plugins ──────────────────────────────────────────────────────
+  if (project.build.plugins.length > 0) {
+    xml += `  <build>\n    <plugins>\n`
+    for (const p of project.build.plugins) xml += pluginBlock(p, '      ')
+    xml += `    </plugins>\n  </build>\n\n`
+  }
+
+  // ── profiles ─────────────────────────────────────────────────────────────
+  if (project.profiles.length > 0) {
+    xml += `  <profiles>\n`
+    for (const p of project.profiles) xml += profileBlock(p)
+    xml += `  </profiles>\n\n`
+  }
+
+  xml += `</project>\n`
+  return xml
+}

package/src/generator/project.ts

@@ -0,0 +1,114 @@
+/**
+ * Legacy / low-level project builder.
+ *
+ * The primary API (generatePom) uses the template engine instead.
+ * This module remains for callers that need the full programmatic
+ * MavenProject model (e.g. unit tests, custom serialization).
+ */
+import type { MavenProject } from '../dependencies/types'
+import { createProject, addDependencyGAV } from '../dependencies/manager'
+import type { CamelKRuntimeConfig } from '../config'
+import { getQuarkusPluginVersion } from '../config'
+
+const CAMEL_K_GROUP        = 'org.apache.camel.k'
+const QUARKUS_PLATFORM     = 'io.quarkus.platform'
+const QUARKUS_PLUGIN_GROUP = 'io.quarkus'
+
+/** Raw JIB profile XML — same as XMLJibProfile in pkg/util/jib/configuration.go. */
+export const JIB_PROFILE_XML = `    <profile>
+      <id>jib</id>
+      <activation>
+        <activeByDefault>false</activeByDefault>
+      </activation>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>com.google.cloud.tools</groupId>
+            <artifactId>jib-maven-plugin</artifactId>
+            <version>3.4.1</version>
+            <dependencies>
+              <dependency>
+                <groupId>com.google.cloud.tools</groupId>
+                <artifactId>jib-layer-filter-extension-maven</artifactId>
+                <version>0.3.0</version>
+              </dependency>
+            </dependencies>
+            <configuration>
+              <container>
+                <entrypoint>INHERIT</entrypoint>
+                <args>
+                  <arg>jshell</arg>
+                </args>
+              </container>
+              <allowInsecureRegistries>true</allowInsecureRegistries>
+              <extraDirectories>
+                <paths>
+                  <path>
+                    <from>../context</from>
+                    <into>/deployments</into>
+                  </path>
+                </paths>
+                <permissions>
+                  <permission>
+                    <file>/deployments/*</file>
+                    <mode>755</mode>
+                  </permission>
+                </permissions>
+              </extraDirectories>
+              <pluginExtensions>
+                <pluginExtension>
+                  <implementation>com.google.cloud.tools.jib.maven.extension.layerfilter.JibLayerFilterExtension</implementation>
+                  <configuration implementation="com.google.cloud.tools.jib.maven.extension.layerfilter.Configuration">
+                    <filters>
+                      <Filter>
+                        <glob>/app/**</glob>
+                      </Filter>
+                    </filters>
+                  </configuration>
+                </pluginExtension>
+              </pluginExtensions>
+            </configuration>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>`
+
+/**
+ * Build a fully-hydrated MavenProject (for use with serializePom).
+ * The primary generatePom() uses templates instead — use this only when you
+ * need the project model for programmatic manipulation.
+ */
+export function createQuarkusProject(
+  integrationArtifactId: string,
+  config: CamelKRuntimeConfig,
+): MavenProject {
+  const project = createProject(
+    'org.apache.camel.k.integration',
+    integrationArtifactId,
+    config.operatorVersion,
+  )
+
+  project.properties['project.build.sourceEncoding'] = 'UTF-8'
+  project.properties['quarkus.package.jar.type'] = 'fast-jar'
+  project.properties['project.build.outputTimestamp'] = new Date().toISOString()
+
+  if (config.flavor === 'plain-quarkus') {
+    project.boms.push({ groupId: QUARKUS_PLATFORM, artifactId: 'quarkus-camel-bom', version: config.runtimeVersion })
+    project.boms.push({ groupId: QUARKUS_PLATFORM, artifactId: 'quarkus-bom',       version: config.runtimeVersion })
+  } else {
+    project.boms.push({ groupId: CAMEL_K_GROUP, artifactId: 'camel-k-runtime-bom', version: config.runtimeVersion })
+    addDependencyGAV(project, CAMEL_K_GROUP, 'camel-k-runtime')
+  }
+
+  project.build.plugins.push({
+    groupId: QUARKUS_PLUGIN_GROUP,
+    artifactId: 'quarkus-maven-plugin',
+    version: getQuarkusPluginVersion(config),
+    extensions: true,
+    executions: [{ id: 'build-integration', goals: ['build'] }],
+  })
+
+  project.profiles.push({ id: 'jib', rawXml: JIB_PROFILE_XML })
+
+  return project
+}

package/src/generator/template.ts

@@ -0,0 +1,125 @@
+/**
+ * Template engine for pom.xml generation.
+ *
+ * The template carries all static structural elements (properties, BOMs,
+ * quarkus-maven-plugin, JIB profile). The only dynamic section is
+ * {{dependencies}}, which is replaced on every generation.
+ *
+ * Supported tokens:
+ *   {{operatorVersion}}      — Camel K operator version (pom <version>)
+ *   {{runtimeVersion}}       — BOM version (quarkus platform or camel-k-runtime)
+ *   {{quarkusPlatformVersion}} — quarkus-maven-plugin version (legacy quarkus only)
+ *   {{outputTimestamp}}      — ISO-8601 build timestamp (reproducible builds)
+ *   {{dependencies}}         — replaced with the full <dependencies> XML block
+ */
+import type { CamelKRuntimeConfig } from '../config'
+import { getQuarkusPluginVersion } from '../config'
+import { PLAIN_QUARKUS_TEMPLATE } from '../templates/plain-quarkus'
+import { QUARKUS_TEMPLATE } from '../templates/quarkus'
+import type { MavenProject } from '../dependencies/types'
+
+// ── Template registry ──────────────────────────────────────────────────────────
+
+/** Return the bundled template for the given runtime flavor. */
+export function getDefaultTemplate(flavor: CamelKRuntimeConfig['flavor']): string {
+  return flavor === 'plain-quarkus' ? PLAIN_QUARKUS_TEMPLATE : QUARKUS_TEMPLATE
+}
+
+// ── Token substitution ────────────────────────────────────────────────────────
+
+export interface TemplateTokens {
+  operatorVersion: string
+  runtimeVersion: string
+  quarkusPlatformVersion: string
+  outputTimestamp: string
+}
+
+export function buildTokens(config: CamelKRuntimeConfig): TemplateTokens {
+  return {
+    operatorVersion:       config.operatorVersion,
+    runtimeVersion:        config.runtimeVersion,
+    quarkusPlatformVersion: getQuarkusPluginVersion(config),
+    outputTimestamp:       new Date().toISOString(),
+  }
+}
+
+function replaceTokens(template: string, tokens: TemplateTokens): string {
+  return template
+    .replace(/\{\{operatorVersion\}\}/g,       tokens.operatorVersion)
+    .replace(/\{\{runtimeVersion\}\}/g,         tokens.runtimeVersion)
+    .replace(/\{\{quarkusPlatformVersion\}\}/g, tokens.quarkusPlatformVersion)
+    .replace(/\{\{outputTimestamp\}\}/g,         tokens.outputTimestamp)
+}
+
+// ── Dependencies block serializer ─────────────────────────────────────────────
+
+function esc(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+function tag(name: string, value: string, indent: string): string {
+  return `${indent}<${name}>${esc(value)}</${name}>\n`
+}
+
+/**
+ * Serialize only the `<dependencies>...</dependencies>` block from the project.
+ * This is the fragment injected into `{{dependencies}}`.
+ */
+export function serializeDepsBlock(project: MavenProject): string {
+  if (project.dependencies.length === 0) return ''
+
+  let xml = `<dependencies>\n`
+  for (const dep of project.dependencies) {
+    const key = `${dep.groupId}:${dep.artifactId}`
+    const exclusions = project.exclusions.get(key) ?? []
+
+    xml += `    <dependency>\n`
+    xml += tag('groupId',    dep.groupId,    '      ')
+    xml += tag('artifactId', dep.artifactId, '      ')
+    if (dep.version)     xml += tag('version',    dep.version,    '      ')
+    if (dep.scope)       xml += tag('scope',      dep.scope,      '      ')
+    if (dep.type)        xml += tag('type',       dep.type,       '      ')
+    if (dep.classifier)  xml += tag('classifier', dep.classifier, '      ')
+    if (exclusions.length > 0) {
+      xml += `      <exclusions>\n`
+      for (const ex of exclusions) {
+        xml += `        <exclusion>\n`
+        xml += tag('groupId',    ex.groupId,    '          ')
+        xml += tag('artifactId', ex.artifactId, '          ')
+        xml += `        </exclusion>\n`
+      }
+      xml += `      </exclusions>\n`
+    }
+    xml += `    </dependency>\n`
+  }
+  xml += `  </dependencies>`
+  return xml
+}
+
+// ── Main render function ──────────────────────────────────────────────────────
+
+/**
+ * Render a pom.xml string by:
+ * 1. Substituting all `{{token}}` placeholders.
+ * 2. Replacing `{{dependencies}}` with the serialized <dependencies> block.
+ *
+ * If the template has no `{{dependencies}}` marker, the deps block is inserted
+ * before `</project>` as a fallback.
+ */
+export function renderTemplate(
+  template: string,
+  tokens: TemplateTokens,
+  project: MavenProject,
+): string {
+  const depsBlock = serializeDepsBlock(project)
+  let result = replaceTokens(template, tokens)
+
+  if (result.includes('{{dependencies}}')) {
+    result = result.replace('{{dependencies}}', depsBlock)
+  } else {
+    // Fallback: insert before </project>
+    result = result.replace('</project>', `  ${depsBlock}\n\n</project>`)
+  }
+
+  return result
+}

package/src/global-config.ts

@@ -0,0 +1,25 @@
+// Reserved for future global configuration options (e.g. FileSystemProvider).
+export interface CamelPomGenConfig {}
+
+let _config: CamelPomGenConfig = {}
+
+/** Set package-level defaults (call once at IDE/app startup). */
+export function configure(config: CamelPomGenConfig): void {
+  _config = { ..._config, ...config }
+}
+
+/** Read the current global config. */
+export function getGlobalConfig(): Readonly<CamelPomGenConfig> {
+  return _config
+}
+
+/**
+ * Resolve the template to use.
+ * Currently returns the bundled default; reserved for future extension.
+ */
+export function resolveTemplate(
+  _inline: string | undefined,
+  defaultTemplate: string,
+): string {
+  return defaultTemplate
+}

package/src/inspector/base.ts

@@ -0,0 +1,193 @@
+/**
+ * Base inspector — regex patterns and shared URI/dependency logic ported from
+ * pkg/util/source/inspector.go in camel-k.
+ */
+import type { CamelCatalog } from '../catalog/types'
+import {
+  decodeComponent,
+  getDependencyID,
+  getArtifactByDataFormat,
+  getLanguageDependency,
+  isResolvable,
+  getURIScheme,
+  isHTTPScheme,
+  isPassiveScheme,
+} from '../catalog/catalog'
+import type { InspectionResult } from './types'
+
+// ─── Regex patterns (mirrors pkg/util/source/inspector.go) ───────────────────
+
+export const RE_FROM            = /from\s*\(\s*"([a-zA-Z0-9-]+:[^"]+)"/g
+export const RE_FROM_F          = /fromF\s*\(\s*"([a-zA-Z0-9-]+:[^"]+)"/g
+export const RE_TO              = /\.to\s*\(\s*"([a-zA-Z0-9-]+:[^"]+)"/g
+export const RE_TO_D            = /\.toD\s*\(\s*"([a-zA-Z0-9-]+:[^"]+)"/g
+export const RE_TO_F            = /\.toF\s*\(\s*"([a-zA-Z0-9-]+:[^"]+)"/g
+export const RE_WIRE_TAP        = /\.wireTap\s*\(\s*"([a-zA-Z0-9-]+:[^"]+)"/g
+export const RE_LANGUAGE        = /language\s*\(\s*["']([a-zA-Z0-9-]+[^"']+)["']\s*,.*\)/g
+export const RE_CAMEL_TYPE      = /.*(org\.apache\.camel.*(?:Component|DataFormat|Language))/g
+export const RE_JSON_LIBRARY    = /.*JsonLibrary\.Jackson.*/
+export const RE_JSON_LANGUAGE   = /.*\.json\(\).*/
+export const RE_BEAN            = /.*\.bean\(.*\).*/
+export const RE_ERROR_HANDLER   = /errorHandler\s*\(\s*deadLetterChannel\s*\(\s*["']([a-zA-Z0-9-]+:[^"']+)["']\s*\).*/g
+export const RE_CIRCUIT_BREAKER = /.*\.circuitBreaker\(\).*/
+export const RE_REST_CONFIG     = /.*restConfiguration\(\).*/
+export const RE_REST            = /.*rest\s*\([^)]*\).*/
+export const RE_REST_CLOSURE    = /.*rest\s*\{\s*/
+export const RE_OPEN_API        = /.*\.openApi\s*\([^)]*\).*/
+export const RE_GROOVY_LANG     = /.*\.groovy\s*\(.*\).*/
+export const RE_JSONPATH_LANG   = /.*\.?(jsonpath|jsonpathWriteAsString)\s*\(.*\).*/
+export const RE_OGNL            = /.*\.ognl\s*\(.*\).*/
+export const RE_MVEL            = /.*\.mvel\s*\(.*\).*/
+export const RE_XQUERY          = /.*\.xquery\s*\(.*\).*/
+export const RE_XPATH           = /.*\.?xpath\s*\(.*\).*/
+export const RE_XTOKENIZE       = /.*\.xtokenize\s*\(.*\).*/
+export const RE_KAMELET_EIP     = /kamelet\s*\(\s*"(?:\/\/)?([a-z0-9-.]+(?:\/[a-z0-9-.]+)?)(?:$|[^a-z0-9-.].*)"/
+
+const DEFAULT_JSON_DF = 'jackson'
+
+// ─── Pattern → dependency resolver map ───────────────────────────────────────
+
+type DepResolver = (catalog: CamelCatalog) => string[]
+
+const PATTERN_DEP_RESOLVERS: Array<[RegExp, DepResolver]> = [
+  [RE_BEAN, (c) => {
+    const a = Object.values(c.artifacts).find(a => a.schemes?.some(s => s.id === 'bean'))
+    return a ? [getDependencyID(a)] : []
+  }],
+  [RE_JSON_LIBRARY, (c) => {
+    const a = getArtifactByDataFormat(c, DEFAULT_JSON_DF)
+    return a ? [getDependencyID(a)] : []
+  }],
+  [RE_JSON_LANGUAGE, (c) => {
+    const a = getArtifactByDataFormat(c, DEFAULT_JSON_DF)
+    return a ? [getDependencyID(a)] : []
+  }],
+  [RE_REST_CONFIG, (c) => capabilityDeps(c, 'rest')],
+  [RE_REST,        (c) => capabilityDeps(c, 'rest')],
+  [RE_REST_CLOSURE,(c) => capabilityDeps(c, 'rest')],
+  [RE_OPEN_API, (c) => {
+    const a = Object.values(c.artifacts).find(a => a.schemes?.some(s => s.id === 'rest-openapi'))
+    return a ? [getDependencyID(a)] : []
+  }],
+  [RE_GROOVY_LANG,  (c) => langDep(c, 'groovy')],
+  [RE_JSONPATH_LANG,(c) => langDep(c, 'jsonpath')],
+  [RE_OGNL,         (c) => langDep(c, 'ognl')],
+  [RE_MVEL,         (c) => langDep(c, 'mvel')],
+  [RE_XQUERY,       (c) => langDep(c, 'xquery')],
+  [RE_XPATH,        (c) => langDep(c, 'xpath')],
+  [RE_XTOKENIZE,    (c) => langDep(c, 'xtokenize')],
+]
+
+function capabilityDeps(catalog: CamelCatalog, cap: string): string[] {
+  const c = catalog.runtime.capabilities[cap]
+  return c?.dependencies.map(d => `mvn:${d.groupId}:${d.artifactId}`) ?? []
+}
+
+function langDep(catalog: CamelCatalog, lang: string): string[] {
+  const dep = getLanguageDependency(catalog, lang)
+  return dep ? [dep] : []
+}
+
+// ─── Shared inspection logic ──────────────────────────────────────────────────
+
+export function createEmptyResult(): InspectionResult {
+  return { fromURIs: [], toURIs: [], dependencies: [], capabilities: [], exposesHTTP: false, passiveOnly: false }
+}
+
+/** Extract all regex-matched group[1] values from a string (resets lastIndex). */
+export function matchAll(re: RegExp, text: string): string[] {
+  const results: string[] = []
+  re.lastIndex = 0
+  let m: RegExpExecArray | null
+  while ((m = re.exec(text)) !== null) {
+    results.push(m[1])
+    if (!re.global) break
+  }
+  re.lastIndex = 0
+  return results
+}
+
+/**
+ * Core analysis: given extracted URIs and full source text, resolve all
+ * dependencies and capabilities against the catalog.
+ */
+export function analyzeWithCatalog(
+  catalog: CamelCatalog,
+  result: InspectionResult,
+  sourceText: string,
+): void {
+  const deps = new Set(result.dependencies)
+  const caps = new Set(result.capabilities)
+
+  // ── URI-based dependencies ─────────────────────────────────────────────────
+  for (const uri of [...result.fromURIs, ...result.toURIs]) {
+    if (!isResolvable(uri)) continue
+    const artifact = decodeComponent(catalog, uri)
+    if (!artifact) continue
+    deps.add(getDependencyID(artifact))
+    // transitive deps declared in the artifact
+    for (const dep of artifact.dependencies ?? []) {
+      deps.add(`mvn:${dep.groupId}:${dep.artifactId}`)
+    }
+  }
+
+  // ── platform-http capability ───────────────────────────────────────────────
+  for (const uri of result.fromURIs) {
+    if (getURIScheme(uri) === 'platform-http') caps.add('platform-http')
+  }
+
+  // ── Pattern-based deps (bean, xpath, rest, ...) ───────────────────────────
+  for (const [pattern, resolver] of PATTERN_DEP_RESOLVERS) {
+    if (pattern.test(sourceText)) {
+      for (const dep of resolver(catalog)) deps.add(dep)
+      if (pattern === RE_REST_CONFIG || pattern === RE_REST || pattern === RE_REST_CLOSURE) {
+        caps.add('rest')
+      }
+    }
+  }
+
+  // ── Circuit breaker capability ─────────────────────────────────────────────
+  if (RE_CIRCUIT_BREAKER.test(sourceText)) {
+    caps.add('circuit-breaker')
+    for (const dep of capabilityDeps(catalog, 'circuit-breaker')) deps.add(dep)
+  }
+
+  // ── language() DSL calls ──────────────────────────────────────────────────
+  for (const lang of matchAll(RE_LANGUAGE, sourceText)) {
+    const dep = getLanguageDependency(catalog, lang.trim())
+    if (dep) deps.add(dep)
+  }
+
+  // ── errorHandler(deadLetterChannel(...)) ──────────────────────────────────
+  for (const uri of matchAll(RE_ERROR_HANDLER, sourceText)) {
+    if (!isResolvable(uri)) continue
+    const artifact = decodeComponent(catalog, uri)
+    if (artifact) deps.add(getDependencyID(artifact))
+  }
+
+  // ── dataformat: URI ───────────────────────────────────────────────────────
+  for (const uri of [...result.fromURIs, ...result.toURIs]) {
+    if (!uri.startsWith('dataformat:')) continue
+    const parts = uri.split(':')
+    if (parts.length >= 3) {
+      const artifact = getArtifactByDataFormat(catalog, parts[1])
+      if (artifact) deps.add(getDependencyID(artifact))
+    }
+  }
+
+  result.dependencies = [...deps]
+  result.capabilities = [...caps]
+
+  // ── HTTP exposure & passive-only ──────────────────────────────────────────
+  result.exposesHTTP =
+    result.capabilities.includes('rest') ||
+    result.fromURIs.some(uri => isHTTPScheme(catalog, getURIScheme(uri)))
+
+  result.passiveOnly =
+    result.fromURIs.length > 0 &&
+    result.fromURIs.every(uri => {
+      if (uri === 'kamelet:source') return true
+      const scheme = getURIScheme(uri)
+      return isPassiveScheme(catalog, scheme) || isHTTPScheme(catalog, scheme)
+    })
+}