Code Correlator

Overview

This skill takes a feature map produced by feature-mapper and correlates each UI feature with the source code that implements it. It maps features to component files, handler functions, and related files that are useful for downstream tool generation. This skill is optional: the pipeline can go directly from feature-mapper to mcp-tool-generator when source correlation is not needed.

Prerequisites Check

1. Check whether local application source code is present by looking for common roots such as src/, app/, pages/, or components/.
2. If no source code is found, do not fail. Inform the user exactly:

"This skill requires access to the application's source code. You can skip this skill and proceed directly to mcp-tool-generator using the feature map."

3. If source code is found, detect framework signals from project files such as package.json, tsconfig.json, vite.config.*, next.config.*, nuxt.config.*, angular.json, and svelte.config.*.
4. If framework detection is unclear, set framework to unknown and continue with generic strategies.

Reference Loading

• Read references/framework-hints.md for framework detection and file/layout patterns.
• Read references/component-discovery.md for ordered correlation strategies.
• Read references/test-patterns.md for optional behavior verification.
• Read references/output-format.md for output schema and required fields.

Correlation Workflow

Step 1: Load Feature Map

• Primary source: latest artifact under .claude/artifacts/feature-map-*/.
• Fallback source: manually supplied feature map input.
• Preserve feature_id values exactly as provided; downstream consumers rely on exact ID stability.

Step 2: Detect Framework

• Use references/framework-hints.md to classify project as one of: react, vue, angular, svelte, vanilla, or unknown.
• Prefer explicit config and dependencies over heuristic extension-only detection.

Step 3: Correlate Each Feature (ordered strategies)

Apply discovery strategies in order from references/component-discovery.md:

1. URL path match
2. Text search
3. Component search
4. LSP reference tracing (when available)

Do not assume any tool provider naming or hardcoded prefixes. Use available search/LSP capabilities in the current environment.

Step 4: Record Mapping

For each successful match, record:

• feature_id
• component_file
• handler_function
• line_range
• framework_detected
• discovery_method
• confidence
• related_files
• test_result

Follow the exact structure defined in references/output-format.md.

Step 5: Optional Verification

• Optionally verify behavior by reading handler code and doing shallow trace checks according to references/test-patterns.md.
• Hard cap tracing to one or two call levels.
• If confidence remains unclear, keep mapping but set conservative confidence and notes.

Step 6: Save Output

• Write artifacts to .claude/artifacts/code-map-{timestamp}/.
• Ensure schema compatibility with references/output-format.md.
• Include both mapped and unmapped features.

Strategy Details for Each Feature

1) URL Path Match

• Convert feature URL paths into likely route/component files.
• Example: /admin/users -> likely pages/admin/users.* or app/admin/users/page.*.

2) Text Search

• Search for UI element labels/headings from feature metadata.
• Use text matches to find candidate files, then filter by framework-relevant file types.

3) Component Search

• Convert feature names into candidate component/function names.
• Validate candidates by checking if file logic and UI structure match the feature intent.

4) LSP References

• When language server support exists, resolve symbol definitions and references to improve precision.
• If unavailable, skip cleanly and continue with non-LSP methods.

Confidence Levels

• High: LSP reference found, or exact route/component file match that clearly contains feature elements and handler.
• Medium: Plausible URL-path or component-name match with supporting evidence.
• Low: Text-search-only or heuristic match with limited corroboration.

Graceful Degradation

• No source code found: skip code correlation and return the prerequisite message.
• Feature cannot be mapped: add entry to unmapped_features with reason and attempted methods.
• Framework not detected: set to unknown and use generic discovery.
• LSP unavailable: skip LSP strategy and proceed with path/text/component search.

Safety and Scope Limits

• Do not modify application source code.
• Do not run the application.
• Do not trace full architecture.
• Keep call-chain analysis shallow (1-2 levels maximum).

Output

Save results to .claude/artifacts/code-map-{timestamp}/ and follow references/output-format.md.