diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json new file mode 100644 index 0000000000..719473def2 --- /dev/null +++ b/.claude-plugin/marketplace.json @@ -0,0 +1,19 @@ +{ + "name": "gitnexus-marketplace", + "owner": { + "name": "GitNexus", + "email": "nico@gitnexus.dev" + }, + "metadata": { + "description": "Code intelligence powered by a knowledge graph — execution flows, blast radius, and semantic search", + "homepage": "https://github.com/nicosxt/gitnexus" + }, + "plugins": [ + { + "name": "gitnexus", + "version": "1.3.3", + "source": "./gitnexus-claude-plugin", + "description": "Code intelligence powered by a knowledge graph. Provides execution flow tracing, blast radius analysis, and augmented search across your codebase." + } + ] +} diff --git a/.claude/settings.local.json b/.claude/settings.local.json deleted file mode 100644 index 380bbf3545..0000000000 --- a/.claude/settings.local.json +++ /dev/null @@ -1,81 +0,0 @@ -{ - "permissions": { - "allow": [ - "WebSearch", - "WebFetch(domain:cursor.com)", - "WebFetch(domain:composio.dev)", - "Bash(npx tsc:*)", - "Bash(claude rename:*)", - "Bash(npm run build:*)", - "Bash(npm link:*)", - "Bash(gitnexus --version:*)", - "Bash(gitnexus --help:*)", - "Bash(npm ls:*)", - "Bash(gitnexus augment:*)", - "Bash(node -e \"\nconst { augment } = await import\\(''./gitnexus/dist/core/augmentation/engine.js''\\);\ntry {\n const r = await augment\\(''setup'', process.cwd\\(\\)\\);\n console.log\\(''Result:'', r ? r.substring\\(0, 200\\) : ''null''\\);\n} catch\\(e\\) { console.error\\(''Error:'', e.message\\); }\nprocess.exit\\(0\\);\n\")", - "Bash(cmd.exe /c \"cd /d D:\\\\Projects\\\\GitnexusV2 && gitnexus augment setup\")", - "Bash(cmd.exe /c \"cd /d D:\\\\Projects\\\\GitnexusV2 && gitnexus status\")", - "Bash(gh repo clone:*)", - "Bash(claude mcp:*)", - "Bash(gh issue view:*)", - "Bash(echo:*)", - "Bash(node:*)", - "Bash(npm view:*)", - "Bash(npm version:*)", - "Bash(npm pack:*)", - "Bash(npm publish:*)", - "Bash(npx gitnexus:*)", - "mcp__gitnexus__list_repos", - "mcp__gitnexus__query", - "mcp__gitnexus__context", - "mcp__gitnexus__impact", - "Bash(git add:*)", - "Bash(Glob)", - "Bash(Bash\"\\) per new Claude Code schema\n- Rename gitnexus-hook.js → gitnexus-hook.cjs for CommonJS compatibility\n- Fix setup.ts: correct hook filename and timeout \\(8000ms instead of 10ms\\)\n- Bump to v1.1.9 and publish to npm\n\nCo-Authored-By: Claude Opus 4.6 \nEOF\n\\)\")", - "Bash(git push:*)", - "WebFetch(domain:docs.kuzudb.com)", - "WebFetch(domain:github.com)", - "WebFetch(domain:raw.githubusercontent.com)", - "WebFetch(domain:read.engineerscodex.com)", - "WebFetch(domain:towardsdatascience.com)", - "WebFetch(domain:kilo.ai)", - "WebFetch(domain:deepwiki.com)", - "WebFetch(domain:turbopuffer.com)", - "WebFetch(domain:windsurf.com)", - "WebFetch(domain:modal.com)", - "WebFetch(domain:www.augmentcode.com)", - "WebFetch(domain:www.qodo.ai)", - "WebFetch(domain:arxiv.org)", - "WebFetch(domain:cognition.ai)", - "WebFetch(domain:microsoft.github.io)", - "WebFetch(domain:github.github.com)", - "WebFetch(domain:gist.github.com)", - "WebFetch(domain:fsoft-ai4code.github.io)", - "mcp__gitnexus__cypher", - "WebFetch(domain:repomix.com)", - "WebFetch(domain:www.humanlayer.dev)", - "WebFetch(domain:agents.md)", - "WebFetch(domain:eclipsesource.com)", - "WebFetch(domain:www.usefulfunctions.co.uk)", - "WebFetch(domain:developers.googleblog.com)", - "WebFetch(domain:www.anthropic.com)", - "WebFetch(domain:www.driver.ai)", - "WebFetch(domain:blog.sshh.io)", - "WebFetch(domain:docs.qodo.ai)", - "WebFetch(domain:smartlogic.io)", - "Bash(ls:*)", - "Bash(wc:*)", - "Bash(grep:*)", - "Bash(powershell -Command:*)", - "Bash(cmd /c \"dir /s C:\\\\Users\\\\ADMIN\\\\.cache\\\\huggingface 2>nul | findstr /i \"\"File\\(s\\)\"\"\")", - "Bash(du:*)", - "mcp__desktop-commander__list_directory", - "Bash(python3 -c \":*)", - "mcp__gitnexus__detect_changes" - ] - }, - "enableAllProjectMcpServers": true, - "enabledMcpjsonServers": [ - "gitnexus" - ] -} diff --git a/.claude/skills/gitnexus/gitnexus-cli/SKILL.md b/.claude/skills/gitnexus/gitnexus-cli/SKILL.md new file mode 100644 index 0000000000..c9e0af341a --- /dev/null +++ b/.claude/skills/gitnexus/gitnexus-cli/SKILL.md @@ -0,0 +1,82 @@ +--- +name: gitnexus-cli +description: "Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: \"Index this repo\", \"Reanalyze the codebase\", \"Generate a wiki\"" +--- + +# GitNexus CLI Commands + +All commands work via `npx` — no global install required. + +## Commands + +### analyze — Build or refresh the index + +```bash +npx gitnexus analyze +``` + +Run from the project root. This parses all source files, builds the knowledge graph, writes it to `.gitnexus/`, and generates CLAUDE.md / AGENTS.md context files. + +| Flag | Effect | +| -------------- | ---------------------------------------------------------------- | +| `--force` | Force full re-index even if up to date | +| `--embeddings` | Enable embedding generation for semantic search (off by default) | + +**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale. In Claude Code, a PostToolUse hook runs `analyze` automatically after `git commit` and `git merge`, preserving embeddings if previously generated. + +### status — Check index freshness + +```bash +npx gitnexus status +``` + +Shows whether the current repo has a GitNexus index, when it was last updated, and symbol/relationship counts. Use this to check if re-indexing is needed. + +### clean — Delete the index + +```bash +npx gitnexus clean +``` + +Deletes the `.gitnexus/` directory and unregisters the repo from the global registry. Use before re-indexing if the index is corrupt or after removing GitNexus from a project. + +| Flag | Effect | +| --------- | ------------------------------------------------- | +| `--force` | Skip confirmation prompt | +| `--all` | Clean all indexed repos, not just the current one | + +### wiki — Generate documentation from the graph + +```bash +npx gitnexus wiki +``` + +Generates repository documentation from the knowledge graph using an LLM. Requires an API key (saved to `~/.gitnexus/config.json` on first use). + +| Flag | Effect | +| ------------------- | ----------------------------------------- | +| `--force` | Force full regeneration | +| `--model ` | LLM model (default: minimax/minimax-m2.5) | +| `--base-url ` | LLM API base URL | +| `--api-key ` | LLM API key | +| `--concurrency ` | Parallel LLM calls (default: 3) | +| `--gist` | Publish wiki as a public GitHub Gist | + +### list — Show all indexed repos + +```bash +npx gitnexus list +``` + +Lists all repositories registered in `~/.gitnexus/registry.json`. The MCP `list_repos` tool provides the same information. + +## After Indexing + +1. **Read `gitnexus://repo/{name}/context`** to verify the index loaded +2. Use the other GitNexus skills (`exploring`, `debugging`, `impact-analysis`, `refactoring`) for your task + +## Troubleshooting + +- **"Not inside a git repository"**: Run from a directory inside a git repo +- **Index is stale after re-analyzing**: Restart Claude Code to reload the MCP server +- **Embeddings slow**: Omit `--embeddings` (it's off by default) or set `OPENAI_API_KEY` for faster API-based embedding diff --git a/.claude/skills/gitnexus/debugging/SKILL.md b/.claude/skills/gitnexus/gitnexus-debugging/SKILL.md similarity index 76% rename from .claude/skills/gitnexus/debugging/SKILL.md rename to .claude/skills/gitnexus/gitnexus-debugging/SKILL.md index 3b945835bd..9510b97ac3 100644 --- a/.claude/skills/gitnexus/debugging/SKILL.md +++ b/.claude/skills/gitnexus/gitnexus-debugging/SKILL.md @@ -1,11 +1,12 @@ --- name: gitnexus-debugging -description: Trace bugs through call chains using knowledge graph +description: "Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: \"Why is X failing?\", \"Where does this error come from?\", \"Trace this bug\"" --- # Debugging with GitNexus ## When to Use + - "Why is this function failing?" - "Trace where this error comes from" - "Who calls this method?" @@ -37,17 +38,18 @@ description: Trace bugs through call chains using knowledge graph ## Debugging Patterns -| Symptom | GitNexus Approach | -|---------|-------------------| -| Error message | `gitnexus_query` for error text → `context` on throw sites | -| Wrong return value | `context` on the function → trace callees for data flow | -| Intermittent failure | `context` → look for external calls, async deps | -| Performance issue | `context` → find symbols with many callers (hot paths) | -| Recent regression | `detect_changes` to see what your changes affect | +| Symptom | GitNexus Approach | +| -------------------- | ---------------------------------------------------------- | +| Error message | `gitnexus_query` for error text → `context` on throw sites | +| Wrong return value | `context` on the function → trace callees for data flow | +| Intermittent failure | `context` → look for external calls, async deps | +| Performance issue | `context` → find symbols with many callers (hot paths) | +| Recent regression | `detect_changes` to see what your changes affect | ## Tools **gitnexus_query** — find code related to error: + ``` gitnexus_query({query: "payment validation error"}) → Processes: CheckoutFlow, ErrorHandling @@ -55,6 +57,7 @@ gitnexus_query({query: "payment validation error"}) ``` **gitnexus_context** — full context for a suspect: + ``` gitnexus_context({name: "validatePayment"}) → Incoming calls: processCheckout, webhookHandler @@ -63,6 +66,7 @@ gitnexus_context({name: "validatePayment"}) ``` **gitnexus_cypher** — custom call chain traces: + ```cypher MATCH path = (a)-[:CodeRelation {type: 'CALLS'}*1..2]->(b:Function {name: "validatePayment"}) RETURN [n IN nodes(path) | n.name] AS chain diff --git a/gitnexus-claude-plugin/skills/exploring/SKILL.md b/.claude/skills/gitnexus/gitnexus-exploring/SKILL.md similarity index 75% rename from gitnexus-claude-plugin/skills/exploring/SKILL.md rename to .claude/skills/gitnexus/gitnexus-exploring/SKILL.md index 2214c289cd..927a4e4b64 100644 --- a/gitnexus-claude-plugin/skills/exploring/SKILL.md +++ b/.claude/skills/gitnexus/gitnexus-exploring/SKILL.md @@ -1,11 +1,12 @@ --- name: gitnexus-exploring -description: Navigate unfamiliar code using GitNexus knowledge graph +description: "Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: \"How does X work?\", \"What calls this function?\", \"Show me the auth flow\"" --- # Exploring Codebases with GitNexus ## When to Use + - "How does authentication work?" - "What's the project structure?" - "Show me the main components" @@ -37,16 +38,17 @@ description: Navigate unfamiliar code using GitNexus knowledge graph ## Resources -| Resource | What you get | -|----------|-------------| -| `gitnexus://repo/{name}/context` | Stats, staleness warning (~150 tokens) | -| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores (~300 tokens) | -| `gitnexus://repo/{name}/cluster/{name}` | Area members with file paths (~500 tokens) | -| `gitnexus://repo/{name}/process/{name}` | Step-by-step execution trace (~200 tokens) | +| Resource | What you get | +| --------------------------------------- | ------------------------------------------------------- | +| `gitnexus://repo/{name}/context` | Stats, staleness warning (~150 tokens) | +| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores (~300 tokens) | +| `gitnexus://repo/{name}/cluster/{name}` | Area members with file paths (~500 tokens) | +| `gitnexus://repo/{name}/process/{name}` | Step-by-step execution trace (~200 tokens) | ## Tools **gitnexus_query** — find execution flows related to a concept: + ``` gitnexus_query({query: "payment processing"}) → Processes: CheckoutFlow, RefundFlow, WebhookHandler @@ -54,6 +56,7 @@ gitnexus_query({query: "payment processing"}) ``` **gitnexus_context** — 360-degree view of a symbol: + ``` gitnexus_context({name: "validateUser"}) → Incoming calls: loginHandler, apiMiddleware diff --git a/.claude/skills/gitnexus/gitnexus-guide/SKILL.md b/.claude/skills/gitnexus/gitnexus-guide/SKILL.md new file mode 100644 index 0000000000..937ac73d16 --- /dev/null +++ b/.claude/skills/gitnexus/gitnexus-guide/SKILL.md @@ -0,0 +1,64 @@ +--- +name: gitnexus-guide +description: "Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: \"What GitNexus tools are available?\", \"How do I use GitNexus?\"" +--- + +# GitNexus Guide + +Quick reference for all GitNexus MCP tools, resources, and the knowledge graph schema. + +## Always Start Here + +For any task involving code understanding, debugging, impact analysis, or refactoring: + +1. **Read `gitnexus://repo/{name}/context`** — codebase overview + check index freshness +2. **Match your task to a skill below** and **read that skill file** +3. **Follow the skill's workflow and checklist** + +> If step 1 warns the index is stale, run `npx gitnexus analyze` in the terminal first. + +## Skills + +| Task | Skill to read | +| -------------------------------------------- | ------------------- | +| Understand architecture / "How does X work?" | `gitnexus-exploring` | +| Blast radius / "What breaks if I change X?" | `gitnexus-impact-analysis` | +| Trace bugs / "Why is X failing?" | `gitnexus-debugging` | +| Rename / extract / split / refactor | `gitnexus-refactoring` | +| Tools, resources, schema reference | `gitnexus-guide` (this file) | +| Index, status, clean, wiki CLI commands | `gitnexus-cli` | + +## Tools Reference + +| Tool | What it gives you | +| ---------------- | ------------------------------------------------------------------------ | +| `query` | Process-grouped code intelligence — execution flows related to a concept | +| `context` | 360-degree symbol view — categorized refs, processes it participates in | +| `impact` | Symbol blast radius — what breaks at depth 1/2/3 with confidence | +| `detect_changes` | Git-diff impact — what do your current changes affect | +| `rename` | Multi-file coordinated rename with confidence-tagged edits | +| `cypher` | Raw graph queries (read `gitnexus://repo/{name}/schema` first) | +| `list_repos` | Discover indexed repos | + +## Resources Reference + +Lightweight reads (~100-500 tokens) for navigation: + +| Resource | Content | +| ---------------------------------------------- | ----------------------------------------- | +| `gitnexus://repo/{name}/context` | Stats, staleness check | +| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores | +| `gitnexus://repo/{name}/cluster/{clusterName}` | Area members | +| `gitnexus://repo/{name}/processes` | All execution flows | +| `gitnexus://repo/{name}/process/{processName}` | Step-by-step trace | +| `gitnexus://repo/{name}/schema` | Graph schema for Cypher | + +## Graph Schema + +**Nodes:** File, Function, Class, Interface, Method, Community, Process +**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS + +```cypher +MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"}) +RETURN caller.name, caller.filePath +``` diff --git a/gitnexus-claude-plugin/skills/impact-analysis/SKILL.md b/.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md similarity index 74% rename from gitnexus-claude-plugin/skills/impact-analysis/SKILL.md rename to .claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md index bb5f51fcc1..e19af280c1 100644 --- a/gitnexus-claude-plugin/skills/impact-analysis/SKILL.md +++ b/.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md @@ -1,11 +1,12 @@ --- name: gitnexus-impact-analysis -description: Analyze blast radius before making code changes +description: "Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: \"Is it safe to change X?\", \"What depends on this?\", \"What will break?\"" --- # Impact Analysis with GitNexus ## When to Use + - "Is it safe to change this function?" - "What will break if I modify X?" - "Show me the blast radius" @@ -37,24 +38,25 @@ description: Analyze blast radius before making code changes ## Understanding Output -| Depth | Risk Level | Meaning | -|-------|-----------|---------| -| d=1 | **WILL BREAK** | Direct callers/importers | -| d=2 | LIKELY AFFECTED | Indirect dependencies | -| d=3 | MAY NEED TESTING | Transitive effects | +| Depth | Risk Level | Meaning | +| ----- | ---------------- | ------------------------ | +| d=1 | **WILL BREAK** | Direct callers/importers | +| d=2 | LIKELY AFFECTED | Indirect dependencies | +| d=3 | MAY NEED TESTING | Transitive effects | ## Risk Assessment -| Affected | Risk | -|----------|------| -| <5 symbols, few processes | LOW | -| 5-15 symbols, 2-5 processes | MEDIUM | -| >15 symbols or many processes | HIGH | +| Affected | Risk | +| ------------------------------ | -------- | +| <5 symbols, few processes | LOW | +| 5-15 symbols, 2-5 processes | MEDIUM | +| >15 symbols or many processes | HIGH | | Critical path (auth, payments) | CRITICAL | ## Tools **gitnexus_impact** — the primary tool for symbol blast radius: + ``` gitnexus_impact({ target: "validateUser", @@ -72,6 +74,7 @@ gitnexus_impact({ ``` **gitnexus_detect_changes** — git-diff based impact analysis: + ``` gitnexus_detect_changes({scope: "staged"}) diff --git a/.claude/skills/gitnexus/gitnexus-pr-review/SKILL.md b/.claude/skills/gitnexus/gitnexus-pr-review/SKILL.md new file mode 100644 index 0000000000..e112f47baa --- /dev/null +++ b/.claude/skills/gitnexus/gitnexus-pr-review/SKILL.md @@ -0,0 +1,163 @@ +--- +name: gitnexus-pr-review +description: "Use when the user wants to review a pull request, understand what a PR changes, assess risk of merging, or check for missing test coverage. Examples: \"Review this PR\", \"What does PR #42 change?\", \"Is this PR safe to merge?\"" +--- + +# PR Review with GitNexus + +## When to Use + +- "Review this PR" +- "What does PR #42 change?" +- "Is this safe to merge?" +- "What's the blast radius of this PR?" +- "Are there missing tests for this PR?" +- Reviewing someone else's code changes before merge + +## Workflow + +``` +1. gh pr diff → Get the raw diff +2. gitnexus_detect_changes({scope: "compare", base_ref: "main"}) → Map diff to affected flows +3. For each changed symbol: + gitnexus_impact({target: "", direction: "upstream"}) → Blast radius per change +4. gitnexus_context({name: ""}) → Understand callers/callees +5. READ gitnexus://repo/{name}/processes → Check affected execution flows +6. Summarize findings with risk assessment +``` + +> If "Index is stale" → run `npx gitnexus analyze` in terminal before reviewing. + +## Checklist + +``` +- [ ] Fetch PR diff (gh pr diff or git diff base...head) +- [ ] gitnexus_detect_changes to map changes to affected execution flows +- [ ] gitnexus_impact on each non-trivial changed symbol +- [ ] Review d=1 items (WILL BREAK) — are callers updated? +- [ ] gitnexus_context on key changed symbols to understand full picture +- [ ] Check if affected processes have test coverage +- [ ] Assess overall risk level +- [ ] Write review summary with findings +``` + +## Review Dimensions + +| Dimension | How GitNexus Helps | +| --- | --- | +| **Correctness** | `context` shows callers — are they all compatible with the change? | +| **Blast radius** | `impact` shows d=1/d=2/d=3 dependents — anything missed? | +| **Completeness** | `detect_changes` shows all affected flows — are they all handled? | +| **Test coverage** | `impact({includeTests: true})` shows which tests touch changed code | +| **Breaking changes** | d=1 upstream items that aren't updated in the PR = potential breakage | + +## Risk Assessment + +| Signal | Risk | +| --- | --- | +| Changes touch <3 symbols, 0-1 processes | LOW | +| Changes touch 3-10 symbols, 2-5 processes | MEDIUM | +| Changes touch >10 symbols or many processes | HIGH | +| Changes touch auth, payments, or data integrity code | CRITICAL | +| d=1 callers exist outside the PR diff | Potential breakage — flag it | + +## Tools + +**gitnexus_detect_changes** — map PR diff to affected execution flows: + +``` +gitnexus_detect_changes({scope: "compare", base_ref: "main"}) + +→ Changed: 8 symbols in 4 files +→ Affected processes: CheckoutFlow, RefundFlow, WebhookHandler +→ Risk: MEDIUM +``` + +**gitnexus_impact** — blast radius per changed symbol: + +``` +gitnexus_impact({target: "validatePayment", direction: "upstream"}) + +→ d=1 (WILL BREAK): + - processCheckout (src/checkout.ts:42) [CALLS, 100%] + - webhookHandler (src/webhooks.ts:15) [CALLS, 100%] + +→ d=2 (LIKELY AFFECTED): + - checkoutRouter (src/routes/checkout.ts:22) [CALLS, 95%] +``` + +**gitnexus_impact with tests** — check test coverage: + +``` +gitnexus_impact({target: "validatePayment", direction: "upstream", includeTests: true}) + +→ Tests that cover this symbol: + - validatePayment.test.ts [direct] + - checkout.integration.test.ts [via processCheckout] +``` + +**gitnexus_context** — understand a changed symbol's role: + +``` +gitnexus_context({name: "validatePayment"}) + +→ Incoming calls: processCheckout, webhookHandler +→ Outgoing calls: verifyCard, fetchRates +→ Processes: CheckoutFlow (step 3/7), RefundFlow (step 1/5) +``` + +## Example: "Review PR #42" + +``` +1. gh pr diff 42 > /tmp/pr42.diff + → 4 files changed: payments.ts, checkout.ts, types.ts, utils.ts + +2. gitnexus_detect_changes({scope: "compare", base_ref: "main"}) + → Changed symbols: validatePayment, PaymentInput, formatAmount + → Affected processes: CheckoutFlow, RefundFlow + → Risk: MEDIUM + +3. gitnexus_impact({target: "validatePayment", direction: "upstream"}) + → d=1: processCheckout, webhookHandler (WILL BREAK) + → webhookHandler is NOT in the PR diff — potential breakage! + +4. gitnexus_impact({target: "PaymentInput", direction: "upstream"}) + → d=1: validatePayment (in PR), createPayment (NOT in PR) + → createPayment uses the old PaymentInput shape — breaking change! + +5. gitnexus_context({name: "formatAmount"}) + → Called by 12 functions — but change is backwards-compatible (added optional param) + +6. Review summary: + - MEDIUM risk — 3 changed symbols affect 2 execution flows + - BUG: webhookHandler calls validatePayment but isn't updated for new signature + - BUG: createPayment depends on PaymentInput type which changed + - OK: formatAmount change is backwards-compatible + - Tests: checkout.test.ts covers processCheckout path, but no webhook test +``` + +## Review Output Format + +Structure your review as: + +```markdown +## PR Review: + +**Risk: LOW / MEDIUM / HIGH / CRITICAL** + +### Changes Summary +- <N> symbols changed across <M> files +- <P> execution flows affected + +### Findings +1. **[severity]** Description of finding + - Evidence from GitNexus tools + - Affected callers/flows + +### Missing Coverage +- Callers not updated in PR: ... +- Untested flows: ... + +### Recommendation +APPROVE / REQUEST CHANGES / NEEDS DISCUSSION +``` diff --git a/.claude/skills/gitnexus/refactoring/SKILL.md b/.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md similarity index 84% rename from .claude/skills/gitnexus/refactoring/SKILL.md rename to .claude/skills/gitnexus/gitnexus-refactoring/SKILL.md index 23f4d11301..f48cc01bd5 100644 --- a/.claude/skills/gitnexus/refactoring/SKILL.md +++ b/.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md @@ -1,11 +1,12 @@ --- name: gitnexus-refactoring -description: Plan safe refactors using blast radius and dependency mapping +description: "Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: \"Rename this function\", \"Extract this into a module\", \"Refactor this class\", \"Move this to a separate file\"" --- # Refactoring with GitNexus ## When to Use + - "Rename this function safely" - "Extract this into a module" - "Split this service" @@ -26,6 +27,7 @@ description: Plan safe refactors using blast radius and dependency mapping ## Checklists ### Rename Symbol + ``` - [ ] gitnexus_rename({symbol_name: "oldName", new_name: "newName", dry_run: true}) — preview all edits - [ ] Review graph edits (high confidence) and ast_search edits (review carefully) @@ -35,6 +37,7 @@ description: Plan safe refactors using blast radius and dependency mapping ``` ### Extract Module + ``` - [ ] gitnexus_context({name: target}) — see all incoming/outgoing refs - [ ] gitnexus_impact({target, direction: "upstream"}) — find all external callers @@ -45,6 +48,7 @@ description: Plan safe refactors using blast radius and dependency mapping ``` ### Split Function/Service + ``` - [ ] gitnexus_context({name: target}) — understand all callees - [ ] Group callees by responsibility @@ -58,6 +62,7 @@ description: Plan safe refactors using blast radius and dependency mapping ## Tools **gitnexus_rename** — automated multi-file rename: + ``` gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true}) → 12 edits across 8 files @@ -66,6 +71,7 @@ gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_ ``` **gitnexus_impact** — map all dependents first: + ``` gitnexus_impact({target: "validateUser", direction: "upstream"}) → d=1: loginHandler, apiMiddleware, testUtils @@ -73,6 +79,7 @@ gitnexus_impact({target: "validateUser", direction: "upstream"}) ``` **gitnexus_detect_changes** — verify your changes after refactoring: + ``` gitnexus_detect_changes({scope: "all"}) → Changed: 8 files, 12 symbols @@ -81,6 +88,7 @@ gitnexus_detect_changes({scope: "all"}) ``` **gitnexus_cypher** — custom reference queries: + ```cypher MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "validateUser"}) RETURN caller.name, caller.filePath ORDER BY caller.filePath @@ -88,12 +96,12 @@ RETURN caller.name, caller.filePath ORDER BY caller.filePath ## Risk Rules -| Risk Factor | Mitigation | -|-------------|------------| -| Many callers (>5) | Use gitnexus_rename for automated updates | -| Cross-area refs | Use detect_changes after to verify scope | -| String/dynamic refs | gitnexus_query to find them | -| External/public API | Version and deprecate properly | +| Risk Factor | Mitigation | +| ------------------- | ----------------------------------------- | +| Many callers (>5) | Use gitnexus_rename for automated updates | +| Cross-area refs | Use detect_changes after to verify scope | +| String/dynamic refs | gitnexus_query to find them | +| External/public API | Version and deprecate properly | ## Example: Rename `validateUser` to `authenticateUser` diff --git a/.github/actions/setup-gitnexus/action.yml b/.github/actions/setup-gitnexus/action.yml new file mode 100644 index 0000000000..fedd2efa8c --- /dev/null +++ b/.github/actions/setup-gitnexus/action.yml @@ -0,0 +1,28 @@ +name: Setup GitNexus +description: Setup Node.js 20, install dependencies, and optionally build + +inputs: + build: + description: Whether to run npm run build after install + required: false + default: 'false' + +runs: + using: composite + steps: + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4 + with: + node-version: 20 + cache: npm + cache-dependency-path: gitnexus/package-lock.json + + - name: Install dependencies + run: npm ci + shell: bash + working-directory: gitnexus + + - name: Build + if: ${{ inputs.build == 'true' }} + run: npm run build + shell: bash + working-directory: gitnexus diff --git a/.github/release.yml b/.github/release.yml new file mode 100644 index 0000000000..1cffb36676 --- /dev/null +++ b/.github/release.yml @@ -0,0 +1,45 @@ +changelog: + exclude: + labels: + - chore + authors: + - dependabot + - dependabot[bot] + categories: + - title: "\U0001F6A8 Security" + labels: + - security + - title: "\U0001F4A5 Breaking Changes" + labels: + - breaking + - title: "\U0001F680 Features" + labels: + - enhancement + - title: "\U0001F41B Bug Fixes" + labels: + - bug + - title: "\U0001F3CE\uFE0F Performance" + labels: + - performance + - title: "\U0001F9EA Tests" + labels: + - test + - title: "\U0001F504 Refactoring" + labels: + - refactor + - title: "\U0001F477 CI/CD" + labels: + - ci + - title: "\U0001F4E6 Dependencies" + labels: + - dependencies + - title: "\U0001F4DD Other Changes" + labels: + - "*" + exclude: + labels: + - dependencies + - ci + - test + - refactor + - chore diff --git a/.github/workflows/ci-quality.yml b/.github/workflows/ci-quality.yml new file mode 100644 index 0000000000..d20e824ab0 --- /dev/null +++ b/.github/workflows/ci-quality.yml @@ -0,0 +1,14 @@ +name: Quality Checks + +on: + workflow_call: + +jobs: + typecheck: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + - uses: ./.github/actions/setup-gitnexus + - run: npx tsc --noEmit + working-directory: gitnexus diff --git a/.github/workflows/ci-tests.yml b/.github/workflows/ci-tests.yml new file mode 100644 index 0000000000..c48401bcd5 --- /dev/null +++ b/.github/workflows/ci-tests.yml @@ -0,0 +1,57 @@ +name: Tests + +on: + workflow_call: + +jobs: + tests: + name: ubuntu / coverage + runs-on: ubuntu-latest + timeout-minutes: 25 + steps: + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + - uses: ./.github/actions/setup-gitnexus + with: + build: 'true' + + - name: Run all tests with coverage + run: >- + npx vitest run + --reporter=default + --reporter=json + --outputFile=test-results.json + --coverage + --coverage.reporter=json-summary + --coverage.reporter=json + --coverage.reporter=text + --coverage.thresholdAutoUpdate=false + --coverage.reportOnFailure=true + working-directory: gitnexus + + - name: Upload test reports + if: always() + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4 + with: + name: test-reports + path: | + gitnexus/coverage/coverage-summary.json + gitnexus/coverage/coverage-final.json + gitnexus/test-results.json + retention-days: 5 + + cross-platform: + name: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + # Ubuntu already covered by the coverage job above + os: [windows-latest, macos-latest] + runs-on: ${{ matrix.os }} + timeout-minutes: 25 + steps: + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + - uses: ./.github/actions/setup-gitnexus + with: + build: 'true' + - run: npx vitest run + working-directory: gitnexus diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 36ccce5bd4..e2a3df8181 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,20 +1,314 @@ name: CI on: + push: + branches: [main] + paths-ignore: ['**.md', 'docs/**', 'LICENSE'] pull_request: branches: [main] + paths-ignore: ['**.md', 'docs/**', 'LICENSE'] + workflow_call: + +concurrency: + group: ci-${{ github.ref }} + cancel-in-progress: true + +# ── Reusable workflow orchestration ───────────────────────────────── +# Each concern lives in its own workflow file for maintainability: +# ci-quality.yml — typecheck (tsc --noEmit) +# ci-tests.yml — all tests with coverage (ubuntu) + cross-platform +# +# The PR report runs inline (not via workflow_run) so it uses the +# PR branch's code instead of main's — avoids stale report templates. jobs: - typecheck: + quality: + uses: ./.github/workflows/ci-quality.yml + permissions: + contents: read + + tests: + uses: ./.github/workflows/ci-tests.yml + permissions: + contents: read + + # ── Unified CI gate ────────────────────────────────────────────── + # Single required check for branch protection. + ci-status: + name: CI Gate + needs: [quality, tests] + if: always() runs-on: ubuntu-latest + timeout-minutes: 5 steps: - - uses: actions/checkout@v4 - - uses: actions/setup-node@v4 + - name: Check all jobs passed + shell: bash + env: + QUALITY: ${{ needs.quality.result }} + TESTS: ${{ needs.tests.result }} + run: | + echo "Quality: $QUALITY" + echo "Tests: $TESTS" + if [[ "$QUALITY" != "success" ]] || + [[ "$TESTS" != "success" ]]; then + echo "::error::One or more CI jobs failed" + exit 1 + fi + + # ── PR Report ──────────────────────────────────────────────────── + # Posts a sticky comment with test results, coverage, and + # per-platform status. Runs inline so it uses the PR branch's + # report template (not main's stale version via workflow_run). + pr-report: + name: PR Report + if: always() && github.event_name == 'pull_request' + needs: [quality, tests] + runs-on: ubuntu-latest + permissions: + contents: read + actions: read + pull-requests: write + timeout-minutes: 5 + steps: + - name: Download test reports + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4 with: - node-version: 20 - cache: npm - cache-dependency-path: gitnexus/package-lock.json - - run: npm ci - working-directory: gitnexus - - run: npx tsc --noEmit - working-directory: gitnexus + name: test-reports + path: ${{ runner.temp }}/test-reports + continue-on-error: true + + - name: Fetch cross-platform job results + id: jobs + uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7 + with: + script: | + const jobs = await github.rest.actions.listJobsForWorkflowRun({ + owner: context.repo.owner, + repo: context.repo.repo, + run_id: context.runId, + per_page: 50, + }); + + const results = {}; + for (const job of jobs.data.jobs) { + if (job.name.includes('ubuntu')) results.ubuntu = job.conclusion || 'pending'; + else if (job.name.includes('windows')) results.windows = job.conclusion || 'pending'; + else if (job.name.includes('macos')) results.macos = job.conclusion || 'pending'; + } + core.setOutput('ubuntu', results.ubuntu || 'unknown'); + core.setOutput('windows', results.windows || 'unknown'); + core.setOutput('macos', results.macos || 'unknown'); + + - name: Fetch base branch coverage + id: base-coverage + uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7 + with: + script: | + const fs = require('fs'); + const path = require('path'); + + const runs = await github.rest.actions.listWorkflowRuns({ + owner: context.repo.owner, + repo: context.repo.repo, + workflow_id: 'ci.yml', + branch: 'main', + status: 'success', + per_page: 1, + }); + + if (runs.data.workflow_runs.length === 0) { + core.setOutput('found', 'false'); + return; + } + + const mainRunId = runs.data.workflow_runs[0].id; + const artifacts = await github.rest.actions.listWorkflowRunArtifacts({ + owner: context.repo.owner, + repo: context.repo.repo, + run_id: mainRunId, + }); + + const testReports = artifacts.data.artifacts.find(a => a.name === 'test-reports'); + if (!testReports) { + core.setOutput('found', 'false'); + return; + } + + const zip = await github.rest.actions.downloadArtifact({ + owner: context.repo.owner, + repo: context.repo.repo, + artifact_id: testReports.id, + archive_format: 'zip', + }); + + const dest = path.join(process.env.RUNNER_TEMP, 'base-coverage'); + fs.mkdirSync(dest, { recursive: true }); + fs.writeFileSync(path.join(dest, 'base.zip'), Buffer.from(zip.data)); + core.setOutput('found', 'true'); + core.setOutput('dir', dest); + + - name: Extract base coverage + if: steps.base-coverage.outputs.found == 'true' + shell: bash + run: | + cd "${{ steps.base-coverage.outputs.dir }}" + unzip -o base.zip -d base + + - name: Build and post report + uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7 + env: + QUALITY: ${{ needs.quality.result }} + TESTS: ${{ needs.tests.result }} + UBUNTU: ${{ steps.jobs.outputs.ubuntu }} + WINDOWS: ${{ steps.jobs.outputs.windows }} + MACOS: ${{ steps.jobs.outputs.macos }} + BASE_FOUND: ${{ steps.base-coverage.outputs.found }} + BASE_DIR: ${{ steps.base-coverage.outputs.dir }} + with: + script: | + const fs = require('fs'); + const path = require('path'); + + const icon = (s) => ({ success: '✅', failure: '❌', cancelled: '⏭️' }[s] || '❓'); + const temp = process.env.RUNNER_TEMP; + + // ── Read coverage ── + function readCov(dir) { + const out = { stmts: 'N/A', branch: 'N/A', funcs: 'N/A', lines: 'N/A', + stmtsCov: '', branchCov: '', funcsCov: '', linesCov: '' }; + try { + const files = require('child_process') + .execSync(`find "${dir}" -name coverage-summary.json -type f`, { encoding: 'utf8' }) + .trim().split('\n').filter(Boolean); + if (!files.length) return out; + const d = JSON.parse(fs.readFileSync(files[0], 'utf8')).total; + out.stmts = d.statements.pct; out.branch = d.branches.pct; + out.funcs = d.functions.pct; out.lines = d.lines.pct; + out.stmtsCov = `${d.statements.covered}/${d.statements.total}`; + out.branchCov = `${d.branches.covered}/${d.branches.total}`; + out.funcsCov = `${d.functions.covered}/${d.functions.total}`; + out.linesCov = `${d.lines.covered}/${d.lines.total}`; + } catch {} + return out; + } + + const cov = readCov(path.join(temp, 'test-reports')); + const base = process.env.BASE_FOUND === 'true' + ? readCov(path.join(process.env.BASE_DIR, 'base')) + : { stmts: 'N/A', branch: 'N/A', funcs: 'N/A', lines: 'N/A' }; + + // ── Read test results ── + let total = 0, passed = 0, failed = 0, skipped = 0, suites = 0, duration = '0s'; + let skippedTests = []; + try { + const files = require('child_process') + .execSync(`find "${path.join(temp, 'test-reports')}" -name test-results.json -type f`, { encoding: 'utf8' }) + .trim().split('\n').filter(Boolean); + if (files.length) { + const r = JSON.parse(fs.readFileSync(files[0], 'utf8')); + total = r.numTotalTests || 0; + passed = r.numPassedTests || 0; + failed = r.numFailedTests || 0; + skipped = r.numPendingTests || 0; + suites = r.numTotalTestSuites || 0; + const durS = Math.floor((Math.max(...r.testResults.map(t => t.endTime)) - r.startTime) / 1000); + duration = durS >= 60 ? `${Math.floor(durS / 60)}m ${durS % 60}s` : `${durS}s`; + // Collect skipped test names + for (const suite of r.testResults) { + for (const t of (suite.assertionResults || [])) { + if (t.status === 'pending' || t.status === 'skipped') { + skippedTests.push(`- ${t.ancestorTitles.join(' > ')} > ${t.title}`); + } + } + } + } + } catch {} + + // ── Coverage delta ── + function delta(pct, basePct) { + if (pct === 'N/A' || basePct === 'N/A') return '—'; + const d = (pct - basePct).toFixed(1); + if (d > 0) return `📈 +${d}%`; + if (d < 0) return `📉 ${d}%`; + return '＝'; + } + + // ── Build markdown ── + const { QUALITY, TESTS, UBUNTU, WINDOWS, MACOS } = process.env; + const overall = (QUALITY === 'success' && TESTS === 'success') + ? '✅ **All checks passed**' : '❌ **Some checks failed**'; + const sha = context.sha.slice(0, 7); + + let body = `## CI Report\n\n${overall}   \`${sha}\`\n\n`; + + body += `### Pipeline\n\n`; + body += `| Stage | Status | Ubuntu | Windows | macOS |\n`; + body += `|-------|--------|--------|---------|-------|\n`; + body += `| Typecheck | ${icon(QUALITY)} \`${QUALITY}\` | — | — | — |\n`; + body += `| Tests | ${icon(TESTS)} \`${TESTS}\` | ${icon(UBUNTU)} | ${icon(WINDOWS)} | ${icon(MACOS)} |\n\n`; + + if (total > 0) { + body += `### Tests\n\n`; + body += `| Metric | Value |\n|--------|-------|\n`; + body += `| Total | **${total}** |\n`; + body += `| Passed | **${passed}** |\n`; + if (failed > 0) body += `| Failed | **${failed}** |\n`; + if (skipped > 0) body += `| Skipped | ${skipped} |\n`; + body += `| Files | ${suites} |\n`; + body += `| Duration | ${duration} |\n\n`; + + if (failed === 0) { + body += `✅ All **${passed}** tests passed across **${suites}** files\n`; + } else { + body += `❌ **${failed}** failed / **${passed}** passed\n`; + } + + if (skippedTests.length > 0) { + body += `\n<details>\n<summary>${skipped} test(s) skipped</summary>\n\n`; + body += skippedTests.join('\n') + '\n\n</details>\n'; + } + body += '\n'; + } + + if (cov.stmts !== 'N/A') { + body += `### Coverage\n\n`; + body += `| Metric | Coverage | Covered | Base (main) | Delta |\n`; + body += `|--------|----------|---------|-------------|-------|\n`; + body += `| Statements | **${cov.stmts}%** | ${cov.stmtsCov} | ${base.stmts}% | ${delta(cov.stmts, base.stmts)} |\n`; + body += `| Branches | **${cov.branch}%** | ${cov.branchCov} | ${base.branch}% | ${delta(cov.branch, base.branch)} |\n`; + body += `| Functions | **${cov.funcs}%** | ${cov.funcsCov} | ${base.funcs}% | ${delta(cov.funcs, base.funcs)} |\n`; + body += `| Lines | **${cov.lines}%** | ${cov.linesCov} | ${base.lines}% | ${delta(cov.lines, base.lines)} |\n\n`; + } else { + body += `### Coverage\n\n⚠️ Coverage data unavailable — check the [test job](${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}) for details.\n\n`; + } + + const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`; + body += `---\n<sub>📋 [Full run](${runUrl}) · Coverage from Ubuntu · Generated by CI</sub>`; + + // ── Post sticky comment ── + const { data: comments } = await github.rest.issues.listComments({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: context.issue.number, + per_page: 100, + }); + + const marker = '<!-- ci-report -->'; + const existing = comments.find(c => c.body?.includes(marker)); + const fullBody = marker + '\n' + body; + + if (existing) { + await github.rest.issues.updateComment({ + owner: context.repo.owner, + repo: context.repo.repo, + comment_id: existing.id, + body: fullBody, + }); + } else { + await github.rest.issues.createComment({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: context.issue.number, + body: fullBody, + }); + } diff --git a/.github/workflows/claude-code-review.yml b/.github/workflows/claude-code-review.yml index b5e8cfd4dc..04795bc18f 100644 --- a/.github/workflows/claude-code-review.yml +++ b/.github/workflows/claude-code-review.yml @@ -1,44 +1,123 @@ name: Claude Code Review +# Uses pull_request_target so the workflow runs as defined on the default branch, +# which allows access to secrets for posting review comments on fork PRs. +# SECURITY: The checkout below uses the PR head SHA to review the correct code. +# The claude-code-action sandboxes execution — it does NOT run arbitrary code +# from the checked-out source. + on: - pull_request: - types: [opened, synchronize, ready_for_review, reopened] - # Optional: Only run on specific file changes - # paths: - # - "src/**/*.ts" - # - "src/**/*.tsx" - # - "src/**/*.js" - # - "src/**/*.jsx" + # Trigger only when explicitly requested: + # - Add the "claude-review" label to a PR, OR + # - Comment "@claude" or "/review" on a PR + pull_request_target: + types: [labeled] + issue_comment: + types: [created] + +# Serialize per-PR so concurrent @claude comments don't race on the +# temporary fork branch push/delete. +concurrency: + group: claude-review-${{ github.event.issue.number || github.event.pull_request.number }} + cancel-in-progress: false jobs: claude-review: - # Optional: Filter by PR author - # if: | - # github.event.pull_request.user.login == 'external-contributor' || - # github.event.pull_request.user.login == 'new-developer' || - # github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR' - + # Run only when: + # 1. The "claude-review" label is added to a non-draft PR by a trusted contributor, OR + # 2. A trusted contributor comments "@claude" or "/review" on a PR + if: | + ( + github.event_name == 'pull_request_target' && + github.event.label.name == 'claude-review' && + github.event.pull_request.draft == false && + (github.event.pull_request.author_association == 'OWNER' || + github.event.pull_request.author_association == 'MEMBER' || + github.event.pull_request.author_association == 'COLLABORATOR') + ) || + ( + github.event_name == 'issue_comment' && + github.event.issue.pull_request && + (contains(github.event.comment.body, '@claude') || + contains(github.event.comment.body, '/review')) && + (github.event.comment.author_association == 'OWNER' || + github.event.comment.author_association == 'MEMBER' || + github.event.comment.author_association == 'COLLABORATOR') + ) runs-on: ubuntu-latest + timeout-minutes: 30 permissions: - contents: read - pull-requests: read + contents: write # needed to create fork branch ref via API + pull-requests: write issues: read id-token: write steps: - - name: Checkout repository - uses: actions/checkout@v4 + # For issue_comment triggers, resolve the PR number, head SHA, and branch name + - name: Resolve PR context + id: pr + uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7 with: + script: | + let pr; + if (context.eventName === 'issue_comment') { + const resp = await github.rest.pulls.get({ + owner: context.repo.owner, + repo: context.repo.repo, + pull_number: context.payload.issue.number, + }); + pr = resp.data; + } else { + pr = context.payload.pull_request; + } + core.setOutput('number', pr.number); + core.setOutput('sha', pr.head.sha); + core.setOutput('branch', pr.head.ref); + core.setOutput('is_fork', String(pr.head.repo.full_name !== pr.base.repo.full_name)); + + - name: Checkout PR head + uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + with: + ref: ${{ steps.pr.outputs.sha }} fetch-depth: 1 + # claude-code-action fetches branches by name from origin, which fails + # for fork PRs. Create a temporary branch ref via the API so the action + # can find it. Using the API (not git push) avoids the GITHUB_TOKEN + # restriction that blocks pushing commits containing workflow file changes. + # Use a prefixed temporary branch name to avoid overwriting real branches + # (e.g. a fork branch named "main" would overwrite origin/main). + - name: Create fork branch ref on origin + id: push-fork + if: steps.pr.outputs.is_fork == 'true' + env: + FORK_BRANCH: claude-tmp/fork-pr-${{ steps.pr.outputs.number }} + FORK_SHA: ${{ steps.pr.outputs.sha }} + GH_TOKEN: ${{ github.token }} + run: | + echo "FORK_BRANCH=$FORK_BRANCH" >> "$GITHUB_ENV" + gh api "repos/${{ github.repository }}/git/refs" \ + --method POST \ + -f ref="refs/heads/$FORK_BRANCH" \ + -f sha="$FORK_SHA" \ + || gh api "repos/${{ github.repository }}/git/refs/heads/$FORK_BRANCH" \ + --method PATCH \ + -f sha="$FORK_SHA" \ + -F force=true + - name: Run Claude Code Review id: claude-review - uses: anthropics/claude-code-action@v1 + uses: anthropics/claude-code-action@9469d113c6afd29550c402740f22d1a97dd1209b # v1 with: claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }} plugin_marketplaces: 'https://github.com/anthropics/claude-code.git' plugins: 'code-review@claude-code-plugins' - prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }}' - # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md - # or https://code.claude.com/docs/en/cli-reference for available options + prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ steps.pr.outputs.number }}' + # Clean up the temporary branch ref we created for fork PRs. + # Only delete if the create step actually succeeded. + - name: Delete fork branch ref from origin + if: always() && steps.push-fork.outcome == 'success' + env: + GH_TOKEN: ${{ github.token }} + run: gh api "repos/${{ github.repository }}/git/refs/heads/$FORK_BRANCH" --method DELETE || true diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml index d300267f18..12fc0ccaa7 100644 --- a/.github/workflows/claude.yml +++ b/.github/workflows/claude.yml @@ -10,6 +10,12 @@ on: pull_request_review: types: [submitted] +# Serialize per-PR so concurrent @claude comments don't race on the +# temporary fork branch push/delete. +concurrency: + group: claude-code-${{ github.event.issue.number || github.event.pull_request.number || github.event.issue.id }} + cancel-in-progress: false + jobs: claude: if: | @@ -18,21 +24,84 @@ jobs: (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) || (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude'))) runs-on: ubuntu-latest + timeout-minutes: 30 permissions: - contents: read - pull-requests: read - issues: read + contents: write # needed to create fork branch ref via API + pull-requests: write + issues: write id-token: write - actions: read # Required for Claude to read CI results on PRs + actions: read # required for Claude to read CI results on PRs steps: - - name: Checkout repository - uses: actions/checkout@v4 + # For PR-related triggers, resolve fork context so we can create a + # temporary branch ref (claude-code-action fetches by branch name). + - name: Resolve PR context + id: pr + uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7 with: + script: | + // Determine if this event is PR-related + let prNumber = null; + if (context.eventName === 'issue_comment' && context.payload.issue.pull_request) { + prNumber = context.payload.issue.number; + } else if (context.eventName === 'pull_request_review_comment') { + prNumber = context.payload.pull_request.number; + } else if (context.eventName === 'pull_request_review') { + prNumber = context.payload.pull_request.number; + } + + if (!prNumber) { + core.setOutput('is_pr', 'false'); + core.setOutput('is_fork', 'false'); + return; + } + + const resp = await github.rest.pulls.get({ + owner: context.repo.owner, + repo: context.repo.repo, + pull_number: prNumber, + }); + const pr = resp.data; + const isFork = pr.head.repo.full_name !== pr.base.repo.full_name; + + core.setOutput('is_pr', 'true'); + core.setOutput('number', String(prNumber)); + core.setOutput('is_fork', String(isFork)); + core.setOutput('branch', pr.head.ref); + core.setOutput('sha', pr.head.sha); + + - name: Checkout repository + uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + with: + ref: ${{ steps.pr.outputs.is_fork == 'true' && steps.pr.outputs.sha || '' }} fetch-depth: 1 + # claude-code-action fetches branches by name from origin, which fails + # for fork PRs. Create a temporary branch ref via the API so the action + # can find it. Using the API (not git push) avoids the GITHUB_TOKEN + # restriction that blocks pushing commits containing workflow file changes. + # Use a prefixed temporary branch name to avoid overwriting real branches + # (e.g. a fork branch named "main" would overwrite origin/main). + - name: Create fork branch ref on origin + id: push-fork + if: steps.pr.outputs.is_fork == 'true' + env: + FORK_BRANCH: claude-tmp/fork-pr-${{ steps.pr.outputs.number }} + FORK_SHA: ${{ steps.pr.outputs.sha }} + GH_TOKEN: ${{ github.token }} + run: | + echo "FORK_BRANCH=$FORK_BRANCH" >> "$GITHUB_ENV" + gh api "repos/${{ github.repository }}/git/refs" \ + --method POST \ + -f ref="refs/heads/$FORK_BRANCH" \ + -f sha="$FORK_SHA" \ + || gh api "repos/${{ github.repository }}/git/refs/heads/$FORK_BRANCH" \ + --method PATCH \ + -f sha="$FORK_SHA" \ + -F force=true + - name: Run Claude Code id: claude - uses: anthropics/claude-code-action@v1 + uses: anthropics/claude-code-action@9469d113c6afd29550c402740f22d1a97dd1209b # v1 with: claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }} @@ -40,11 +109,10 @@ jobs: additional_permissions: | actions: read - # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it. - # prompt: 'Update the pull request description to include a summary of changes.' - - # Optional: Add claude_args to customize behavior and configuration - # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md - # or https://code.claude.com/docs/en/cli-reference for available options - # claude_args: '--allowed-tools Bash(gh pr:*)' - + # Clean up the temporary branch ref we created for fork PRs. + # Only delete if the create step actually succeeded. + - name: Delete fork branch ref from origin + if: always() && steps.push-fork.outcome == 'success' + env: + GH_TOKEN: ${{ github.token }} + run: gh api "repos/${{ github.repository }}/git/refs/heads/$FORK_BRANCH" --method DELETE || true diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 66d6c1bb9c..13d00954e4 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -5,14 +5,25 @@ on: tags: - 'v*' +# No workflow-level permissions — scoped per job below. + jobs: - publish: - runs-on: ubuntu-latest + ci: + uses: ./.github/workflows/ci.yml permissions: contents: read + pull-requests: write + + publish: + needs: ci + runs-on: ubuntu-latest + timeout-minutes: 15 + permissions: + contents: write + id-token: write steps: - - uses: actions/checkout@v4 - - uses: actions/setup-node@v4 + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4 with: node-version: 20 registry-url: https://registry.npmjs.org @@ -20,9 +31,38 @@ jobs: cache-dependency-path: gitnexus/package-lock.json - run: npm ci working-directory: gitnexus - - run: npx tsc --noEmit + + - name: Verify version consistency + shell: bash + run: | + TAG_VERSION="${GITHUB_REF#refs/tags/v}" + if ! [[ "$TAG_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.]+)?$ ]]; then + echo "::error::Tag does not follow semver: v$TAG_VERSION" + exit 1 + fi + PKG_VERSION=$(node -p "require('./package.json').version") + if [ "$TAG_VERSION" != "$PKG_VERSION" ]; then + echo "::error::Tag version (v$TAG_VERSION) does not match package.json version ($PKG_VERSION)" + exit 1 + fi + echo "Version verified: $PKG_VERSION" working-directory: gitnexus - - run: npm publish + + - name: Build + run: npm run build + working-directory: gitnexus + + - name: Dry-run publish + run: npm publish --dry-run + working-directory: gitnexus + + - name: Publish to npm + run: npm publish --provenance --access public working-directory: gitnexus env: NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + + - name: Create GitHub Release + uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2 + with: + generate_release_notes: true diff --git a/.gitignore b/.gitignore index 345ee8e077..509bdbb1e8 100644 --- a/.gitignore +++ b/.gitignore @@ -17,6 +17,8 @@ dist/ .DS_Store Thumbs.db +.claude/settings.local.json + # Environment variables .env .env.local @@ -41,10 +43,14 @@ coverage/ .env*.local .gitnexus +.claude/settings.local.json # Claude Code worktrees .claude/worktrees/ +# Claude code skills +.claude/skills/generated/ + # Assets (screenshots, images) assets/ @@ -53,3 +59,14 @@ repomix-output* # Design docs (local only) docs/plans/ + +gitnexus/test/fixtures/mini-repo/*.md +gitnexus/test/fixtures/mini-repo/.claude +gitnexus/test/fixtures/mini-repo/.gitignore + +# Ignore csharp generated obj and bin folders +gitnexus/test/fixtures/lang-resolution/**/obj +gitnexus/test/fixtures/lang-resolution/**/bin +GitNexus.sln +# Git worktrees +.worktrees/ diff --git a/.history/gitnexus/vitest.config_20260317171253.ts b/.history/gitnexus/vitest.config_20260317171253.ts new file mode 100644 index 0000000000..b3beecb1b4 --- /dev/null +++ b/.history/gitnexus/vitest.config_20260317171253.ts @@ -0,0 +1,33 @@ +import { defineConfig } from 'vitest/config'; + +export default defineConfig({ + test: { + globalSetup: ['test/global-setup.ts'], + include: ['test/**/*.test.ts'], + testTimeout: 30000, + hookTimeout: 120000, + pool: 'forks', + globals: true, + setupFiles: ['test/setup.ts'], + teardownTimeout: 3000, + dangerouslyIgnoreUnhandledErrors: true, // LadybugDB N-API destructor segfaults on fork exit — not a test failure + coverage: { + provider: 'v8', + include: ['src/**/*.ts'], + exclude: [ + 'src/cli/index.ts', // CLI entry point (commander wiring) + 'src/server/**', // HTTP server (requires network) + 'src/core/wiki/**', // Wiki generation (requires LLM) + ], + // Auto-ratchet: vitest bumps thresholds when coverage exceeds them. + // CI will fail if a PR drops below these floors. + thresholds: { + statements: 26, + branches: 23, + functions: 28, + lines: 27, + autoUpdate: true, + }, + }, + }, +}); diff --git a/AGENTS.md b/AGENTS.md index d5b788b41f..58eead9d6d 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,64 +1,101 @@ -# AI Agent Rules - <!-- gitnexus:start --> -# GitNexus MCP +# GitNexus — Code Intelligence -This project is indexed by GitNexus as **GitnexusV2** (1348 symbols, 3469 relationships, 104 execution flows). +This project is indexed by GitNexus as **GitNexus** (2094 symbols, 4982 relationships, 159 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely. -GitNexus provides a knowledge graph over this codebase — call chains, blast radius, execution flows, and semantic search. +> If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first. -## Always Start Here +## Always Do -For any task involving code understanding, debugging, impact analysis, or refactoring, you must: +- **MUST run impact analysis before editing any symbol.** Before modifying a function, class, or method, run `gitnexus_impact({target: "symbolName", direction: "upstream"})` and report the blast radius (direct callers, affected processes, risk level) to the user. +- **MUST run `gitnexus_detect_changes()` before committing** to verify your changes only affect expected symbols and execution flows. +- **MUST warn the user** if impact analysis returns HIGH or CRITICAL risk before proceeding with edits. +- When exploring unfamiliar code, use `gitnexus_query({query: "concept"})` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance. +- When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use `gitnexus_context({name: "symbolName"})`. -1. **Read `gitnexus://repo/{name}/context`** — codebase overview + check index freshness -2. **Match your task to a skill below** and **read that skill file** -3. **Follow the skill's workflow and checklist** +## When Debugging -> If step 1 warns the index is stale, run `npx gitnexus analyze` in the terminal first. +1. `gitnexus_query({query: "<error or symptom>"})` — find execution flows related to the issue +2. `gitnexus_context({name: "<suspect function>"})` — see all callers, callees, and process participation +3. `READ gitnexus://repo/GitNexus/process/{processName}` — trace the full execution flow step by step +4. For regressions: `gitnexus_detect_changes({scope: "compare", base_ref: "main"})` — see what your branch changed -## Skills +## When Refactoring + +- **Renaming**: MUST use `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` first. Review the preview — graph edits are safe, text_search edits need manual review. Then run with `dry_run: false`. +- **Extracting/Splitting**: MUST run `gitnexus_context({name: "target"})` to see all incoming/outgoing refs, then `gitnexus_impact({target: "target", direction: "upstream"})` to find all external callers before moving code. +- After any refactor: run `gitnexus_detect_changes({scope: "all"})` to verify only expected files changed. + +## Never Do + +- NEVER edit a function, class, or method without first running `gitnexus_impact` on it. +- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis. +- NEVER rename symbols with find-and-replace — use `gitnexus_rename` which understands the call graph. +- NEVER commit changes without running `gitnexus_detect_changes()` to check affected scope. + +## Tools Quick Reference + +| Tool | When to use | Command | +|------|-------------|---------| +| `query` | Find code by concept | `gitnexus_query({query: "auth validation"})` | +| `context` | 360-degree view of one symbol | `gitnexus_context({name: "validateUser"})` | +| `impact` | Blast radius before editing | `gitnexus_impact({target: "X", direction: "upstream"})` | +| `detect_changes` | Pre-commit scope check | `gitnexus_detect_changes({scope: "staged"})` | +| `rename` | Safe multi-file rename | `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` | +| `cypher` | Custom graph queries | `gitnexus_cypher({query: "MATCH ..."})` | + +## Impact Risk Levels + +| Depth | Meaning | Action | +|-------|---------|--------| +| d=1 | WILL BREAK — direct callers/importers | MUST update these | +| d=2 | LIKELY AFFECTED — indirect deps | Should test | +| d=3 | MAY NEED TESTING — transitive | Test if critical path | + +## Resources + +| Resource | Use for | +|----------|---------| +| `gitnexus://repo/GitNexus/context` | Codebase overview, check index freshness | +| `gitnexus://repo/GitNexus/clusters` | All functional areas | +| `gitnexus://repo/GitNexus/processes` | All execution flows | +| `gitnexus://repo/GitNexus/process/{name}` | Step-by-step execution trace | + +## Self-Check Before Finishing + +Before completing any code modification task, verify: +1. `gitnexus_impact` was run for all modified symbols +2. No HIGH/CRITICAL risk warnings were ignored +3. `gitnexus_detect_changes()` confirms changes match expected scope +4. All d=1 (WILL BREAK) dependents were updated + +## Keeping the Index Fresh + +After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it: + +```bash +npx gitnexus analyze +``` + +If the index previously included embeddings, preserve them by adding `--embeddings`: + +```bash +npx gitnexus analyze --embeddings +``` + +To check whether embeddings exist, inspect `.gitnexus/meta.json` — the `stats.embeddings` field shows the count (0 means no embeddings). **Running analyze without `--embeddings` will delete any previously generated embeddings.** + +> Claude Code users: A PostToolUse hook handles this automatically after `git commit` and `git merge`. + +## CLI | Task | Read this skill file | |------|---------------------| -| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/exploring/SKILL.md` | -| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/impact-analysis/SKILL.md` | -| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/debugging/SKILL.md` | -| Rename / extract / split / refactor | `.claude/skills/gitnexus/refactoring/SKILL.md` | - -## Tools Reference - -| Tool | What it gives you | -|------|-------------------| -| `query` | Process-grouped code intelligence — execution flows related to a concept | -| `context` | 360-degree symbol view — categorized refs, processes it participates in | -| `impact` | Symbol blast radius — what breaks at depth 1/2/3 with confidence | -| `detect_changes` | Git-diff impact — what do your current changes affect | -| `rename` | Multi-file coordinated rename with confidence-tagged edits | -| `cypher` | Raw graph queries (read `gitnexus://repo/{name}/schema` first) | -| `list_repos` | Discover indexed repos | - -## Resources Reference - -Lightweight reads (~100-500 tokens) for navigation: - -| Resource | Content | -|----------|---------| -| `gitnexus://repo/{name}/context` | Stats, staleness check | -| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores | -| `gitnexus://repo/{name}/cluster/{clusterName}` | Area members | -| `gitnexus://repo/{name}/processes` | All execution flows | -| `gitnexus://repo/{name}/process/{processName}` | Step-by-step trace | -| `gitnexus://repo/{name}/schema` | Graph schema for Cypher | - -## Graph Schema - -**Nodes:** File, Function, Class, Interface, Method, Community, Process -**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS - -```cypher -MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"}) -RETURN caller.name, caller.filePath -``` +| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/gitnexus-exploring/SKILL.md` | +| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md` | +| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/gitnexus-debugging/SKILL.md` | +| Rename / extract / split / refactor | `.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md` | +| Tools, resources, schema reference | `.claude/skills/gitnexus/gitnexus-guide/SKILL.md` | +| Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` | <!-- gitnexus:end --> diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000000..23077f538d --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,109 @@ +# Changelog + +All notable changes to GitNexus will be documented in this file. + +## [Unreleased] + +### Changed +- Migrated from KuzuDB to LadybugDB v0.15 (`@ladybugdb/core`, `@ladybugdb/wasm-core`) +- Renamed all internal paths from `kuzu` to `lbug` (storage: `.gitnexus/kuzu` → `.gitnexus/lbug`) +- Added automatic cleanup of stale KuzuDB index files +- LadybugDB v0.15 requires explicit VECTOR extension loading for semantic search + +## [1.4.0] - 2026-03-13 + +### Added + +- **Language-aware symbol resolution engine** with 3-tier resolver: exact FQN → scope-walk → guarded fuzzy fallback that refuses ambiguous matches (#238) — @magyargergo +- **Method Resolution Order (MRO)** with 5 language-specific strategies: C++ leftmost-base, C#/Java class-over-interface, Python C3 linearization, Rust qualified syntax, default BFS (#238) — @magyargergo +- **Constructor & struct literal resolution** across all languages — `new Foo()`, `User{...}`, C# primary constructors, target-typed new (#238) — @magyargergo +- **Receiver-constrained resolution** using per-file TypeEnv — disambiguates `user.save()` vs `repo.save()` via `ownerId` matching (#238) — @magyargergo +- **Heritage & ownership edges** — HAS_METHOD, OVERRIDES, Go struct embedding, Swift extension heritage, method signatures (`parameterCount`, `returnType`) (#238) — @magyargergo +- **Language-specific resolver directory** (`resolvers/`) — extracted JVM, Go, C#, PHP, Rust resolvers from monolithic import-processor (#238) — @magyargergo +- **Type extractor directory** (`type-extractors/`) — per-language type binding extraction with `Record<SupportedLanguages, Handler>` + `satisfies` dispatch (#238) — @magyargergo +- **Export detection dispatch table** — compile-time exhaustive `Record` + `satisfies` pattern replacing switch/if chains (#238) — @magyargergo +- **Language config module** (`language-config.ts`) — centralized tsconfig, go.mod, composer.json, .csproj, Swift package config loaders (#238) — @magyargergo +- **Optional skill generation** via `npx gitnexus analyze --skills` — generates AI agent skills from KuzuDB knowledge graph (#171) — @zander-raycraft +- **First-class C# support** — sibling-based modifier scanning, record/delegate/property/field/event declaration types (#163, #170, #178 via #237) — @Alice523, @benny-yamagata, @jnMetaCode +- **C/C++ support fixes** — `.h` → C++ mapping, static-linkage export detection, qualified/parenthesized declarators, 48 entry point patterns (#163, #227 via #237) — @Alice523, @bitgineer +- **Rust support fixes** — sibling-based `visibility_modifier` scanning for `pub` detection (#227 via #237) — @bitgineer +- **Adaptive tree-sitter buffer sizing** — `Math.min(Math.max(contentLength * 2, 512KB), 32MB)` (#216 via #237) — @JasonOA888 +- **Call expression matching** in tree-sitter queries (#234 via #237) — @ex-nihilo-jg +- **DeepSeek model configurations** (#217) — @JasonOA888 +- 282+ new unit tests, 178 integration resolver tests across 9 languages, 53 test files, 1146 total tests passing + +### Fixed + +- Skip unavailable native Swift parsers in sequential ingestion (#188) — @Gujiassh +- Heritage heuristic language-gated — no longer applies class/interface rules to wrong languages (#238) — @magyargergo +- C# `base_list` distinguishes EXTENDS vs IMPLEMENTS via symbol table + `I[A-Z]` heuristic (#238) — @magyargergo +- Go `qualified_type` (`models.User`) correctly unwrapped in TypeEnv (#238) — @magyargergo +- Global tier no longer blocks resolution when kind/arity filtering can narrow to 1 candidate (#238) — @magyargergo + +### Changed + +- `import-processor.ts` reduced from 1412 → 711 lines (50% reduction) via resolver and config extraction (#238) — @magyargergo +- `type-env.ts` reduced from 635 → ~125 lines via type-extractor extraction (#238) — @magyargergo +- CI/CD workflows hardened with security fixes and fork PR support (#222, #225) — @magyargergo + +## [1.3.11] - 2026-03-08 + +### Security + +- Fix FTS Cypher injection by escaping backslashes in search queries (#209) — @magyargergo + +### Added + +- Auto-reindex hook that runs `gitnexus analyze` after commits and merges, with automatic embeddings preservation (#205) — @L1nusB +- 968 integration tests (up from ~840) covering unhappy paths across search, enrichment, CLI, pipeline, worker pool, and KuzuDB (#209) — @magyargergo +- Coverage auto-ratcheting so thresholds bump automatically on CI (#209) — @magyargergo +- Rich CI PR report with coverage bars, test counts, and threshold tracking (#209) — @magyargergo +- Modular CI workflow architecture with separate unit-test, integration-test, and orchestrator jobs (#209) — @magyargergo + +### Fixed + +- KuzuDB native addon crashes on Linux/macOS by running integration tests in isolated vitest processes with `--pool=forks` (#209) — @magyargergo +- Worker pool `MODULE_NOT_FOUND` crash when script path is invalid (#209) — @magyargergo + +### Changed + +- Added macOS to the cross-platform CI test matrix (#208) — @magyargergo + +## [1.3.10] - 2026-03-07 + +### Security + +- **MCP transport buffer cap**: Added 10 MB `MAX_BUFFER_SIZE` limit to prevent out-of-memory attacks via oversized `Content-Length` headers or unbounded newline-delimited input +- **Content-Length validation**: Reject `Content-Length` values exceeding the buffer cap before allocating memory +- **Stack overflow prevention**: Replaced recursive `readNewlineMessage` with iterative loop to prevent stack overflow from consecutive empty lines +- **Ambiguous prefix hardening**: Tightened `looksLikeContentLength` to require 14+ bytes before matching, preventing false framing detection on short input +- **Closed transport guard**: `send()` now rejects with a clear error when called after `close()`, with proper write-error propagation + +### Added + +- **Dual-framing MCP transport** (`CompatibleStdioServerTransport`): Auto-detects Content-Length (Codex/OpenCode) and newline-delimited JSON (Cursor/Claude Code) framing on the first message, responds in the same format (#207) +- **Lazy CLI module loading**: All CLI subcommands now use `createLazyAction()` to defer heavy imports (tree-sitter, ONNX, KuzuDB) until invocation, significantly improving `gitnexus mcp` startup time (#207) +- **Type-safe lazy actions**: `createLazyAction` uses constrained generics to validate export names against module types at compile time +- **Regression test suite**: 13 unit tests covering transport framing, security hardening, buffer limits, and lazy action loading + +### Fixed + +- **CALLS edge sourceId alignment**: `findEnclosingFunctionId` now generates IDs with `:startLine` suffix matching node creation format, fixing process detector finding 0 entry points (#194) +- **LRU cache zero maxSize crash**: Guard `createASTCache` against `maxSize=0` when repos have no parseable files (#144) + +### Changed + +- Transport constructor accepts `NodeJS.ReadableStream` / `NodeJS.WritableStream` (widened from concrete `ReadStream`/`WriteStream`) +- `processReadBuffer` simplified to break on first error instead of stale-buffer retry loop + +## [1.3.9] - 2026-03-06 + +### Fixed + +- Aligned CALLS edge sourceId with node ID format in parse worker (#194) + +## [1.3.8] - 2026-03-05 + +### Fixed + +- Force-exit after analyze to prevent KuzuDB native cleanup hang (#192) diff --git a/CLAUDE.md b/CLAUDE.md index 3fbcde0343..58eead9d6d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,62 +1,101 @@ <!-- gitnexus:start --> -# GitNexus MCP +# GitNexus — Code Intelligence -This project is indexed by GitNexus as **GitnexusV2** (1348 symbols, 3469 relationships, 104 execution flows). +This project is indexed by GitNexus as **GitNexus** (2094 symbols, 4982 relationships, 159 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely. -GitNexus provides a knowledge graph over this codebase — call chains, blast radius, execution flows, and semantic search. +> If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first. -## Always Start Here +## Always Do -For any task involving code understanding, debugging, impact analysis, or refactoring, you must: +- **MUST run impact analysis before editing any symbol.** Before modifying a function, class, or method, run `gitnexus_impact({target: "symbolName", direction: "upstream"})` and report the blast radius (direct callers, affected processes, risk level) to the user. +- **MUST run `gitnexus_detect_changes()` before committing** to verify your changes only affect expected symbols and execution flows. +- **MUST warn the user** if impact analysis returns HIGH or CRITICAL risk before proceeding with edits. +- When exploring unfamiliar code, use `gitnexus_query({query: "concept"})` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance. +- When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use `gitnexus_context({name: "symbolName"})`. -1. **Read `gitnexus://repo/{name}/context`** — codebase overview + check index freshness -2. **Match your task to a skill below** and **read that skill file** -3. **Follow the skill's workflow and checklist** +## When Debugging -> If step 1 warns the index is stale, run `npx gitnexus analyze` in the terminal first. +1. `gitnexus_query({query: "<error or symptom>"})` — find execution flows related to the issue +2. `gitnexus_context({name: "<suspect function>"})` — see all callers, callees, and process participation +3. `READ gitnexus://repo/GitNexus/process/{processName}` — trace the full execution flow step by step +4. For regressions: `gitnexus_detect_changes({scope: "compare", base_ref: "main"})` — see what your branch changed -## Skills +## When Refactoring + +- **Renaming**: MUST use `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` first. Review the preview — graph edits are safe, text_search edits need manual review. Then run with `dry_run: false`. +- **Extracting/Splitting**: MUST run `gitnexus_context({name: "target"})` to see all incoming/outgoing refs, then `gitnexus_impact({target: "target", direction: "upstream"})` to find all external callers before moving code. +- After any refactor: run `gitnexus_detect_changes({scope: "all"})` to verify only expected files changed. + +## Never Do + +- NEVER edit a function, class, or method without first running `gitnexus_impact` on it. +- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis. +- NEVER rename symbols with find-and-replace — use `gitnexus_rename` which understands the call graph. +- NEVER commit changes without running `gitnexus_detect_changes()` to check affected scope. + +## Tools Quick Reference + +| Tool | When to use | Command | +|------|-------------|---------| +| `query` | Find code by concept | `gitnexus_query({query: "auth validation"})` | +| `context` | 360-degree view of one symbol | `gitnexus_context({name: "validateUser"})` | +| `impact` | Blast radius before editing | `gitnexus_impact({target: "X", direction: "upstream"})` | +| `detect_changes` | Pre-commit scope check | `gitnexus_detect_changes({scope: "staged"})` | +| `rename` | Safe multi-file rename | `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` | +| `cypher` | Custom graph queries | `gitnexus_cypher({query: "MATCH ..."})` | + +## Impact Risk Levels + +| Depth | Meaning | Action | +|-------|---------|--------| +| d=1 | WILL BREAK — direct callers/importers | MUST update these | +| d=2 | LIKELY AFFECTED — indirect deps | Should test | +| d=3 | MAY NEED TESTING — transitive | Test if critical path | + +## Resources + +| Resource | Use for | +|----------|---------| +| `gitnexus://repo/GitNexus/context` | Codebase overview, check index freshness | +| `gitnexus://repo/GitNexus/clusters` | All functional areas | +| `gitnexus://repo/GitNexus/processes` | All execution flows | +| `gitnexus://repo/GitNexus/process/{name}` | Step-by-step execution trace | + +## Self-Check Before Finishing + +Before completing any code modification task, verify: +1. `gitnexus_impact` was run for all modified symbols +2. No HIGH/CRITICAL risk warnings were ignored +3. `gitnexus_detect_changes()` confirms changes match expected scope +4. All d=1 (WILL BREAK) dependents were updated + +## Keeping the Index Fresh + +After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it: + +```bash +npx gitnexus analyze +``` + +If the index previously included embeddings, preserve them by adding `--embeddings`: + +```bash +npx gitnexus analyze --embeddings +``` + +To check whether embeddings exist, inspect `.gitnexus/meta.json` — the `stats.embeddings` field shows the count (0 means no embeddings). **Running analyze without `--embeddings` will delete any previously generated embeddings.** + +> Claude Code users: A PostToolUse hook handles this automatically after `git commit` and `git merge`. + +## CLI | Task | Read this skill file | |------|---------------------| -| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/exploring/SKILL.md` | -| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/impact-analysis/SKILL.md` | -| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/debugging/SKILL.md` | -| Rename / extract / split / refactor | `.claude/skills/gitnexus/refactoring/SKILL.md` | - -## Tools Reference - -| Tool | What it gives you | -|------|-------------------| -| `query` | Process-grouped code intelligence — execution flows related to a concept | -| `context` | 360-degree symbol view — categorized refs, processes it participates in | -| `impact` | Symbol blast radius — what breaks at depth 1/2/3 with confidence | -| `detect_changes` | Git-diff impact — what do your current changes affect | -| `rename` | Multi-file coordinated rename with confidence-tagged edits | -| `cypher` | Raw graph queries (read `gitnexus://repo/{name}/schema` first) | -| `list_repos` | Discover indexed repos | - -## Resources Reference - -Lightweight reads (~100-500 tokens) for navigation: - -| Resource | Content | -|----------|---------| -| `gitnexus://repo/{name}/context` | Stats, staleness check | -| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores | -| `gitnexus://repo/{name}/cluster/{clusterName}` | Area members | -| `gitnexus://repo/{name}/processes` | All execution flows | -| `gitnexus://repo/{name}/process/{processName}` | Step-by-step trace | -| `gitnexus://repo/{name}/schema` | Graph schema for Cypher | - -## Graph Schema - -**Nodes:** File, Function, Class, Interface, Method, Community, Process -**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS - -```cypher -MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"}) -RETURN caller.name, caller.filePath -``` +| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/gitnexus-exploring/SKILL.md` | +| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md` | +| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/gitnexus-debugging/SKILL.md` | +| Rename / extract / split / refactor | `.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md` | +| Tools, resources, schema reference | `.claude/skills/gitnexus/gitnexus-guide/SKILL.md` | +| Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` | <!-- gitnexus:end --> diff --git a/README.md b/README.md index f24d3f4df0..a885fcf6ef 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,30 @@ # GitNexus +⚠️ Important Notice:** GitNexus has NO official cryptocurrency, token, or coin. Any token/coin using the GitNexus name on Pump.fun or any other platform is **not affiliated with, endorsed by, or created by** this project or its maintainers. Do not purchase any cryptocurrency claiming association with GitNexus. -<a href="https://trendshift.io/repositories/19809" target="_blank"><img src="https://trendshift.io/api/badge/repositories/19809" alt="abhigyanpatwari%2FGitNexus | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a> +<div align="center"> -**Building git for agent context.** + <a href="https://trendshift.io/repositories/19809" target="_blank"> + <img src="https://trendshift.io/api/badge/repositories/19809" alt="abhigyanpatwari%2FGitNexus | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/> + </a> + + <h2>Join the official Discord to discuss ideas, issues etc!</h2> + + <a href="https://discord.gg/AAsRVT6fGb"> + <img src="https://img.shields.io/discord/1477255801545429032?color=5865F2&logo=discord&logoColor=white" alt="Discord"/> + </a> + <a href="https://www.npmjs.com/package/gitnexus"> + <img src="https://img.shields.io/npm/v/gitnexus.svg" alt="npm version"/> + </a> + <a href="https://polyformproject.org/licenses/noncommercial/1.0.0/"> + <img src="https://img.shields.io/badge/License-PolyForm%20Noncommercial-blue.svg" alt="License: PolyForm Noncommercial"/> + </a> + +</div> + +**Building nervous system for agent context.** Indexes any codebase into a knowledge graph — every dependency, call chain, cluster, and execution flow — then exposes it through smart tools so AI agents never miss code. -[![npm version](https://img.shields.io/npm/v/gitnexus.svg)](https://www.npmjs.com/package/gitnexus) -[![License: PolyForm Noncommercial](https://img.shields.io/badge/License-PolyForm%20Noncommercial-blue.svg)](https://polyformproject.org/licenses/noncommercial/1.0.0/) @@ -34,7 +51,7 @@ https://github.com/user-attachments/assets/172685ba-8e54-4ea7-9ad1-e31a3398da72 | **For** | Daily development with Cursor, Claude Code, Codex, Windsurf, OpenCode | Quick exploration, demos, one-off analysis | | **Scale** | Full repos, any size | Limited by browser memory (~5k files), or unlimited via backend mode | | **Install** | `npm install -g gitnexus` | No install —[gitnexus.vercel.app](https://gitnexus.vercel.app) | -| **Storage** | KuzuDB native (fast, persistent) | KuzuDB WASM (in-memory, per session) | +| **Storage** | LadybugDB native (fast, persistent) | LadybugDB WASM (in-memory, per session) | | **Parsing** | Tree-sitter native bindings | Tree-sitter WASM | | **Privacy** | Everything local, no network | Everything in-browser, no server | @@ -65,13 +82,14 @@ To configure MCP for your editor, run `npx gitnexus setup` once — or set it up | Editor | MCP | Skills | Hooks (auto-augment) | Support | | --------------------- | --- | ------ | -------------------- | -------------- | -| **Claude Code** | Yes | Yes | Yes (PreToolUse) | **Full** | +| **Claude Code** | Yes | Yes | Yes (PreToolUse + PostToolUse) | **Full** | | **Cursor** | Yes | Yes | — | MCP + Skills | | **Codex** | Yes | Yes | — | MCP + Skills | | **Windsurf** | Yes | — | — | MCP | | **OpenCode** | Yes | Yes | — | MCP + Skills | +| **Codex** | Yes | — | — | MCP | -> **Claude Code** gets the deepest integration: MCP tools + agent skills + PreToolUse hooks that automatically enrich grep/glob/bash calls with knowledge graph context. +> **Claude Code** gets the deepest integration: MCP tools + agent skills + PreToolUse hooks that enrich searches with graph context + PostToolUse hooks that auto-reindex after commits. ### Community Integrations @@ -119,13 +137,24 @@ codex mcp add gitnexus -- npx -y gitnexus@latest mcp } ``` +**Codex** (`~/.codex/config.toml` for system scope, or `.codex/config.toml` for project scope): + +```toml +[mcp_servers.gitnexus] +command = "npx" +args = ["-y", "gitnexus@latest", "mcp"] +``` + ### CLI Commands ```bash gitnexus setup # Configure MCP for your editors (one-time) gitnexus analyze [path] # Index a repository (or update stale index) gitnexus analyze --force # Force full re-index +gitnexus analyze --skills # Generate repo-specific skill files from detected communities gitnexus analyze --skip-embeddings # Skip embedding generation (faster) +gitnexus analyze --embeddings # Enable embedding generation (slower, better search) +gitnexus analyze --verbose # Log skipped files when parsers are unavailable gitnexus mcp # Start MCP server (stdio) — serves all indexed repos gitnexus serve # Start local HTTP server (multi-repo) for web UI connection gitnexus list # List all indexed repositories @@ -179,6 +208,10 @@ gitnexus wiki --base-url <url> # Wiki with custom LLM API base URL - **Impact Analysis** — Analyze blast radius before changes - **Refactoring** — Plan safe refactors using dependency mapping +**Repo-specific skills** generated with `--skills`: + +When you run `gitnexus analyze --skills`, GitNexus detects the functional areas of your codebase (via Leiden community detection) and generates a `SKILL.md` file for each one under `.claude/skills/generated/`. Each skill describes a module's key files, entry points, execution flows, and cross-area connections — so your AI agent gets targeted context for the exact area of code you're working in. Skills are regenerated on each `--skills` run to stay current with the codebase. + --- ## Multi-Repo MCP Architecture @@ -207,8 +240,8 @@ flowchart TD Server["server.ts"] Backend["LocalBackend"] Pool["Connection Pool"] - ConnA["KuzuDB conn A"] - ConnB["KuzuDB conn B"] + ConnA["LadybugDB conn A"] + ConnB["LadybugDB conn B"] end Setup -->|"writes global MCP config"| CursorConfig["~/.cursor/mcp.json"] @@ -225,7 +258,7 @@ flowchart TD ConnB -->|"queries"| RepoB ``` -**How it works:** Each `gitnexus analyze` stores the index in `.gitnexus/` inside the repo (portable, gitignored) and registers a pointer in `~/.gitnexus/registry.json`. When an AI agent starts, the MCP server reads the registry and can serve any indexed repo. KuzuDB connections are opened lazily on first query and evicted after 5 minutes of inactivity (max 5 concurrent). If only one repo is indexed, the `repo` parameter is optional on all tools — agents don't need to change anything. +**How it works:** Each `gitnexus analyze` stores the index in `.gitnexus/` inside the repo (portable, gitignored) and registers a pointer in `~/.gitnexus/registry.json`. When an AI agent starts, the MCP server reads the registry and can serve any indexed repo. LadybugDB connections are opened lazily on first query and evicted after 5 minutes of inactivity (max 5 concurrent). If only one repo is indexed, the `repo` parameter is optional on all tools — agents don't need to change anything. --- @@ -246,7 +279,7 @@ npm install npm run dev ``` -The web UI uses the same indexing pipeline as the CLI but runs entirely in WebAssembly (Tree-sitter WASM, KuzuDB WASM, in-browser embeddings). It's great for quick exploration but limited by browser memory for larger repos. +The web UI uses the same indexing pipeline as the CLI but runs entirely in WebAssembly (Tree-sitter WASM, LadybugDB WASM, in-browser embeddings). It's great for quick exploration but limited by browser memory for larger repos. **Local Backend Mode:** Run `gitnexus serve` and open the web UI locally — it auto-detects the server and shows all your indexed repos, with full AI chat support. No need to re-upload or re-index. The agent's tools (Cypher queries, search, code navigation) route through the backend HTTP API automatically. @@ -303,14 +336,30 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas 1. **Structure** — Walks the file tree and maps folder/file relationships 2. **Parsing** — Extracts functions, classes, methods, and interfaces using Tree-sitter ASTs -3. **Resolution** — Resolves imports and function calls across files with language-aware logic +3. **Resolution** — Resolves imports, function calls, heritage, constructor inference, and `self`/`this` receiver types across files with language-aware logic 4. **Clustering** — Groups related symbols into functional communities 5. **Processes** — Traces execution flows from entry points through call chains 6. **Search** — Builds hybrid search indexes for fast retrieval ### Supported Languages -TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust +| Language | Imports | Named Bindings | Exports | Heritage | Type Annotations | Constructor Inference | Config | Frameworks | Entry Points | +|----------|---------|----------------|---------|----------|-----------------|---------------------|--------|------------|-------------| +| TypeScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| JavaScript | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | +| Python | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| Java | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | +| Kotlin | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | +| C# | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| Go | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| Rust | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | +| PHP | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | +| Ruby | ✓ | — | ✓ | ✓ | — | ✓ | — | ✓ | ✓ | +| Swift | — | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| C | — | — | ✓ | — | ✓ | ✓ | — | ✓ | ✓ | +| C++ | — | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | + +**Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics --- @@ -449,7 +498,7 @@ The wiki generator reads the indexed graph structure, groups files into modules | ------------------------- | ------------------------------------- | --------------------------------------- | | **Runtime** | Node.js (native) | Browser (WASM) | | **Parsing** | Tree-sitter native bindings | Tree-sitter WASM | -| **Database** | KuzuDB native | KuzuDB WASM | +| **Database** | LadybugDB native | LadybugDB WASM | | **Embeddings** | HuggingFace transformers.js (GPU/CPU) | transformers.js (WebGPU/WASM) | | **Search** | BM25 + semantic + RRF | BM25 + semantic + RRF | | **Agent Interface** | MCP (stdio) | LangChain ReAct agent | @@ -470,9 +519,10 @@ The wiki generator reads the indexed graph structure, groups files into modules ### Recently Completed +- [X] Constructor-Inferred Type Resolution, `self`/`this` Receiver Mapping - [X] Wiki Generation, Multi-File Rename, Git-Diff Impact Analysis - [X] Process-Grouped Search, 360-Degree Context, Claude Code Hooks -- [X] Multi-Repo MCP, Zero-Config Setup, 9 Language Support +- [X] Multi-Repo MCP, Zero-Config Setup, 13 Language Support - [X] Community Detection, Process Detection, Confidence Scoring - [X] Hybrid Search, Vector Index @@ -489,7 +539,7 @@ The wiki generator reads the indexed graph structure, groups files into modules ## Acknowledgments - [Tree-sitter](https://tree-sitter.github.io/) — AST parsing -- [KuzuDB](https://kuzudb.com/) — Embedded graph database with vector support +- [LadybugDB](https://ladybugdb.com/) — Embedded graph database with vector support (formerly KuzuDB) - [Sigma.js](https://www.sigmajs.org/) — WebGL graph rendering - [transformers.js](https://huggingface.co/docs/transformers.js) — Browser ML - [Graphology](https://graphology.github.io/) — Graph data structures diff --git a/compound-engineering.local.md b/compound-engineering.local.md new file mode 100644 index 0000000000..0ad71c2014 --- /dev/null +++ b/compound-engineering.local.md @@ -0,0 +1,57 @@ +--- +review_agents: [kieran-typescript-reviewer, pattern-recognition-specialist, architecture-strategist, data-integrity-guardian, security-sentinel, performance-oracle, code-simplicity-reviewer] +plan_review_agents: [kieran-typescript-reviewer, architecture-strategist, code-simplicity-reviewer] +voltagent_agents: [voltagent-lang:typescript-pro, voltagent-qa-sec:security-auditor, voltagent-data-ai:database-optimizer] +--- + +# Review Context + +## Project Overview +GitNexus is a code intelligence tool that builds a knowledge graph from source code using tree-sitter AST parsing across 12 languages and KuzuDB for graph storage. Two packages: `gitnexus/` (CLI/MCP, TypeScript) and `gitnexus-web/` (browser). + +## Cross-Language Pattern Consistency (pattern-recognition-specialist) +- 12 language-specific type extractors in `gitnexus/src/core/ingestion/type-extractors/` must follow identical patterns for: async unwrapping, constructor binding, namespace handling, nullable type stripping, for-loop element typing. +- Past bugs: C#/Rust missing `await_expression` unwrapping that TypeScript handled correctly; PHP backslash namespace splitting inconsistent with other languages' `::` / `.` splitting. +- When reviewing type extractor changes, verify the same pattern exists in ALL applicable language files — asymmetry is the #1 source of bugs. + +## Data Integrity (data-integrity-guardian) +- KuzuDB graph operations: schema in `gitnexus/src/core/kuzu/schema.ts`, adapter in `kuzu-adapter.ts`. +- The ingestion pipeline writes symbols and relationships to the graph — changes to node/relation schemas or the ingestion pipeline can corrupt the index. +- Known issue: KuzuDB `close()` hangs on Linux due to C++ destructor — use `detachKuzu()` pattern. +- `lbug-adapter.ts` fallback path needs quote/newline escaping for Cypher injection prevention. + +## Security (security-sentinel) +- Cypher query construction in `lbug-adapter.ts` and `kuzu-adapter.ts` — watch for injection via unescaped user-provided symbol names. +- CLI accepts `--repo` parameter and file paths — validate against path traversal. +- MCP server exposes tools to external AI agents — all tool inputs are untrusted. + +## Performance (performance-oracle) +- Tree-sitter buffer size is adaptive (512KB–32MB) via `getTreeSitterBufferSize()` in `constants.ts`. +- The ingestion pipeline processes entire repositories — O(n) per file with potential O(n²) in cross-file resolution. +- KuzuDB batch inserts vs individual inserts matter for large repos. + +## Architecture (architecture-strategist) +- Ingestion pipeline phases: structure → parsing → imports → calls → heritage → processes → type resolution. +- Shared modules: `export-detection.ts`, `constants.ts`, `utils.ts` — changes here have wide blast radius. +- `gitnexus-web` package drifts behind CLI — flag if a change should be mirrored. + +## Voltagent Supplementary Agents + +Invoke these via the Agent tool alongside `/ce:review` for deeper specialist analysis. These cover gaps that compound-engineering agents don't: + +### voltagent-lang:typescript-pro +**When:** Changes touch type-resolution logic, generics, conditional types, or complex type-level programming in `type-env.ts`, `type-extractors/*.ts`, or `types.ts`. +**Why:** The type resolution system uses advanced TypeScript patterns (discriminated unions, mapped types, recursive generics) that benefit from deep TS type-system review beyond what kieran-typescript-reviewer covers. + +### voltagent-qa-sec:security-auditor +**When:** Changes touch MCP tool handlers, Cypher query construction, CLI argument parsing, or any code that processes external input. +**Why:** GitNexus is an MCP server — all tool inputs come from untrusted AI agents. Systematic OWASP-level audit catches injection vectors that spot-checking misses. Past finding: `lbug-adapter.ts` fallback path had unescaped newlines in Cypher queries. + +### voltagent-data-ai:database-optimizer +**When:** Changes touch `kuzu-adapter.ts`, `schema.ts`, `lbug-adapter.ts`, or any Cypher query construction/execution. +**Why:** No CE agent specializes in graph database optimization. KuzuDB batch insert patterns, index usage, and query planning directly affect analysis speed on large repos. + +## Review Tooling +- Use `gitnexus_impact()` before approving changes to any symbol — check d=1 (WILL BREAK) callers. +- Use `gitnexus_detect_changes({scope: "compare", base_ref: "main"})` to map PR diffs to affected execution flows. +- Use claude-mem to surface past architectural decisions relevant to the code under review. diff --git a/eval/README.md b/eval/README.md index d268e67b05..d20f8b837e 100644 --- a/eval/README.md +++ b/eval/README.md @@ -148,7 +148,7 @@ Each mode has a `system_{mode}.jinja` + `instance_{mode}.jinja` pair. The agent 1. Docker container starts with SWE-bench instance (repo at specific commit) 2. **GitNexus setup**: Node.js + gitnexus installed, `gitnexus analyze` runs (or restores from cache) -3. **Eval-server starts**: `gitnexus eval-server` daemon (persistent HTTP server, keeps KuzuDB warm) +3. **Eval-server starts**: `gitnexus eval-server` daemon (persistent HTTP server, keeps LadybugDB warm) 4. **Standalone tool scripts installed** in `/usr/local/bin/` — works with `subprocess.run` (no `.bashrc` needed) 5. Agent runs with the configured model + system prompt + GitNexus tools 6. Agent's patch is extracted as a git diff @@ -167,7 +167,7 @@ Each tool script in `/usr/local/bin/` is standalone — no sourcing, no env inhe ### Eval-server The eval-server is a lightweight HTTP daemon that: -- Keeps KuzuDB warm in memory (no cold start per tool call) +- Keeps LadybugDB warm in memory (no cold start per tool call) - Returns LLM-friendly text (not raw JSON — saves tokens) - Includes next-step hints to guide tool chaining (query → context → impact → fix) - Auto-shuts down after idle timeout diff --git a/eval/configs/models/deepseek-chat.yaml b/eval/configs/models/deepseek-chat.yaml new file mode 100644 index 0000000000..e649a021f1 --- /dev/null +++ b/eval/configs/models/deepseek-chat.yaml @@ -0,0 +1,13 @@ +model: deepseek-ai/deepseek-chat +provider: openrouter +cost: + input: 0.14 # per 1M tokens + output: 0.28 # per 1M tokens + +# Native DeepSeek API (direct) +api_key: null +base_url: null + +# For OpenRouter, uncomment below and comment out direct config above +# api_key: \${OPENROUTER_API_KEY} +# base_url: https://openrouter.ai/api/v1 diff --git a/eval/configs/models/deepseek-v3.yaml b/eval/configs/models/deepseek-v3.yaml new file mode 100644 index 0000000000..f15c5b7a62 --- /dev/null +++ b/eval/configs/models/deepseek-v3.yaml @@ -0,0 +1,15 @@ +model: deepseek-ai/DeepSeek-V3 +provider: openrouter +cost: + input: 0.27 # per 1M tokens + output: 1.10 # per 1M tokens + +# Native DeepSeek API (direct) +# Get your API key at: https://platform.deepseek.com/ +# Or use OpenRouter with: OPENROUTER_API_KEY +api_key: null +base_url: null + +# For OpenRouter, uncomment below and comment out direct config above +# api_key: \${OPENROUTER_API_KEY} +# base_url: https://openrouter.ai/api/v1 diff --git a/gitnexus-claude-plugin/.claude-plugin/plugin.json b/gitnexus-claude-plugin/.claude-plugin/plugin.json index 0772c90dfc..bd4b8c4267 100644 --- a/gitnexus-claude-plugin/.claude-plugin/plugin.json +++ b/gitnexus-claude-plugin/.claude-plugin/plugin.json @@ -1,10 +1,11 @@ { "name": "gitnexus", "description": "Code intelligence powered by a knowledge graph. Provides execution flow tracing, blast radius analysis, and augmented search across your codebase.", - "version": "1.0.0", + "version": "1.3.6", "author": { "name": "GitNexus" }, - "homepage": "https://github.com/nicosxt/gitnexus", - "repository": "https://github.com/nicosxt/gitnexus" + "homepage": "https://github.com/abhigyanpatwari/GitNexus", + "repository": "https://github.com/abhigyanpatwari/GitNexus", + "keywords": ["code-intelligence", "knowledge-graph", "mcp", "static-analysis"] } diff --git a/gitnexus-claude-plugin/.mcp.json b/gitnexus-claude-plugin/.mcp.json new file mode 100644 index 0000000000..cd02d4285a --- /dev/null +++ b/gitnexus-claude-plugin/.mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "gitnexus": { + "command": "npx", + "args": ["-y", "gitnexus@latest", "mcp"] + } + } +} diff --git a/gitnexus-claude-plugin/hooks/gitnexus-hook.js b/gitnexus-claude-plugin/hooks/gitnexus-hook.js index 67c890ff5b..4cc79c100b 100644 --- a/gitnexus-claude-plugin/hooks/gitnexus-hook.js +++ b/gitnexus-claude-plugin/hooks/gitnexus-hook.js @@ -1,17 +1,19 @@ #!/usr/bin/env node /** - * GitNexus Claude Code Hook + * GitNexus Claude Code Plugin Hook * - * PreToolUse handler — intercepts Grep/Glob/Bash searches - * and augments with graph context from the GitNexus index. + * PreToolUse — intercepts Grep/Glob/Bash searches and augments + * with graph context from the GitNexus index. + * PostToolUse — detects stale index after git mutations and notifies + * the agent to reindex. * - * NOTE: SessionStart hooks are broken on Windows (Claude Code bug). + * NOTE: SessionStart hooks are broken on Windows (Claude Code bug #23576). * Session context is injected via CLAUDE.md / skills instead. */ const fs = require('fs'); const path = require('path'); -const { execFileSync } = require('child_process'); +const { spawnSync } = require('child_process'); /** * Read JSON input from stdin synchronously. @@ -26,19 +28,19 @@ function readInput() { } /** - * Check if a directory (or ancestor) has a .gitnexus index. + * Find the .gitnexus directory by walking up from startDir. + * Returns the path to .gitnexus/ or null if not found. */ -function findGitNexusIndex(startDir) { +function findGitNexusDir(startDir) { let dir = startDir || process.cwd(); for (let i = 0; i < 5; i++) { - if (fs.existsSync(path.join(dir, '.gitnexus'))) { - return true; - } + const candidate = path.join(dir, '.gitnexus'); + if (fs.existsSync(candidate)) return candidate; const parent = path.dirname(dir); if (parent === dir) break; dir = parent; } - return false; + return null; } /** @@ -83,40 +85,146 @@ function extractPattern(toolName, toolInput) { return null; } +/** + * Spawn a gitnexus CLI command synchronously. + * Detects binary on PATH once, then runs exactly once. + * + * SECURITY: Never use shell: true with user-controlled arguments. + * On Windows, invoke gitnexus.cmd directly (no shell needed). + */ +function runGitNexusCli(args, cwd, timeout) { + const isWin = process.platform === 'win32'; + + // Detect whether 'gitnexus' is on PATH (cheap check, no execution) + let useDirectBinary = false; + try { + const which = spawnSync( + isWin ? 'where' : 'which', ['gitnexus'], + { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] } + ); + useDirectBinary = which.status === 0; + } catch { /* not on PATH */ } + + if (useDirectBinary) { + return spawnSync( + isWin ? 'gitnexus.cmd' : 'gitnexus', args, + { encoding: 'utf-8', timeout, cwd, stdio: ['pipe', 'pipe', 'pipe'] } + ); + } + // npx fallback needs shell on Windows since npx is a .cmd script + return spawnSync( + isWin ? 'npx.cmd' : 'npx', ['-y', 'gitnexus', ...args], + { encoding: 'utf-8', timeout: timeout + 5000, cwd, stdio: ['pipe', 'pipe', 'pipe'] } + ); +} + +/** + * Emit a hook response with additional context for the agent. + */ +function sendHookResponse(hookEventName, message) { + console.log(JSON.stringify({ + hookSpecificOutput: { hookEventName, additionalContext: message } + })); +} + +/** + * PreToolUse handler — augment searches with graph context. + */ +function handlePreToolUse(input) { + const cwd = input.cwd || process.cwd(); + if (!path.isAbsolute(cwd)) return; + if (!findGitNexusDir(cwd)) return; + + const toolName = input.tool_name || ''; + const toolInput = input.tool_input || {}; + + if (toolName !== 'Grep' && toolName !== 'Glob' && toolName !== 'Bash') return; + + const pattern = extractPattern(toolName, toolInput); + if (!pattern || pattern.length < 3) return; + + let result = ''; + try { + const child = runGitNexusCli(['augment', '--', pattern], cwd, 7000); + if (!child.error && child.status === 0) { + result = child.stderr || ''; + } + } catch { /* graceful failure */ } + + if (result && result.trim()) { + sendHookResponse('PreToolUse', result.trim()); + } +} + +/** + * PostToolUse handler — detect index staleness after git mutations. + * + * Instead of spawning a full `gitnexus analyze` synchronously (which blocks + * the agent for up to 120s and risks LadybugDB corruption on timeout), we do a + * lightweight staleness check: compare `git rev-parse HEAD` against the + * lastCommit stored in `.gitnexus/meta.json`. If they differ, notify the + * agent so it can decide when to reindex. + */ +function handlePostToolUse(input) { + const toolName = input.tool_name || ''; + if (toolName !== 'Bash') return; + + const command = (input.tool_input || {}).command || ''; + if (!/\bgit\s+(commit|merge|rebase|cherry-pick|pull)(\s|$)/.test(command)) return; + + // Only proceed if the command succeeded + const toolOutput = input.tool_output || {}; + if (toolOutput.exit_code !== undefined && toolOutput.exit_code !== 0) return; + + const cwd = input.cwd || process.cwd(); + if (!path.isAbsolute(cwd)) return; + const gitNexusDir = findGitNexusDir(cwd); + if (!gitNexusDir) return; + + // Compare HEAD against last indexed commit — skip if unchanged + let currentHead = ''; + try { + const headResult = spawnSync('git', ['rev-parse', 'HEAD'], { + encoding: 'utf-8', timeout: 3000, cwd, stdio: ['pipe', 'pipe', 'pipe'], + }); + currentHead = (headResult.stdout || '').trim(); + } catch { return; } + + if (!currentHead) return; + + let lastCommit = ''; + let hadEmbeddings = false; + try { + const meta = JSON.parse(fs.readFileSync(path.join(gitNexusDir, 'meta.json'), 'utf-8')); + lastCommit = meta.lastCommit || ''; + hadEmbeddings = (meta.stats && meta.stats.embeddings > 0); + } catch { /* no meta — treat as stale */ } + + // If HEAD matches last indexed commit, no reindex needed + if (currentHead && currentHead === lastCommit) return; + + const analyzeCmd = `npx gitnexus analyze${hadEmbeddings ? ' --embeddings' : ''}`; + sendHookResponse('PostToolUse', + `GitNexus index is stale (last indexed: ${lastCommit ? lastCommit.slice(0, 7) : 'never'}). ` + + `Run \`${analyzeCmd}\` to update the knowledge graph.` + ); +} + +// Dispatch map for hook events +const handlers = { + PreToolUse: handlePreToolUse, + PostToolUse: handlePostToolUse, +}; + function main() { try { const input = readInput(); - const hookEvent = input.hook_event_name || ''; - - if (hookEvent !== 'PreToolUse') return; - - const cwd = input.cwd || process.cwd(); - if (!findGitNexusIndex(cwd)) return; - - const toolName = input.tool_name || ''; - const toolInput = input.tool_input || {}; - - if (toolName !== 'Grep' && toolName !== 'Glob' && toolName !== 'Bash') return; - - const pattern = extractPattern(toolName, toolInput); - if (!pattern || pattern.length < 3) return; - - const result = execFileSync( - 'gitnexus', - ['augment', pattern], - { encoding: 'utf-8', timeout: 8000, cwd, stdio: ['pipe', 'pipe', 'pipe'] } - ); - - if (result && result.trim()) { - console.log(JSON.stringify({ - hookSpecificOutput: { - hookEventName: 'PreToolUse', - additionalContext: result.trim() - } - })); + const handler = handlers[input.hook_event_name || '']; + if (handler) handler(input); + } catch (err) { + if (process.env.GITNEXUS_DEBUG) { + console.error('GitNexus hook error:', (err.message || '').slice(0, 200)); } - } catch { - // Graceful failure } } diff --git a/gitnexus-claude-plugin/hooks/hooks.json b/gitnexus-claude-plugin/hooks/hooks.json index 2e9cb49b21..f9ed9f84af 100644 --- a/gitnexus-claude-plugin/hooks/hooks.json +++ b/gitnexus-claude-plugin/hooks/hooks.json @@ -12,6 +12,19 @@ } ] } + ], + "PostToolUse": [ + { + "matcher": "Bash", + "hooks": [ + { + "type": "command", + "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/gitnexus-hook.js", + "timeout": 10, + "statusMessage": "Checking GitNexus index freshness..." + } + ] + } ] } } diff --git a/gitnexus-claude-plugin/hooks/pre-tool-use.sh b/gitnexus-claude-plugin/hooks/pre-tool-use.sh deleted file mode 100644 index 3c1af3bc0c..0000000000 --- a/gitnexus-claude-plugin/hooks/pre-tool-use.sh +++ /dev/null @@ -1,78 +0,0 @@ -#!/bin/bash -# GitNexus PreToolUse hook for Claude Code -# Intercepts Grep/Glob/Bash searches and augments with graph context. -# Receives JSON on stdin with { tool_name, tool_input, cwd, ... } -# Returns JSON with additionalContext for graph-enriched results. - -INPUT=$(cat) - -TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null) -CWD=$(echo "$INPUT" | jq -r '.cwd // empty' 2>/dev/null) - -# Extract search pattern based on tool type -PATTERN="" - -case "$TOOL_NAME" in - Grep) - PATTERN=$(echo "$INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null) - ;; - Glob) - # Glob patterns are file paths, not search terms — extract meaningful part - RAW=$(echo "$INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null) - # Strip glob syntax to get the meaningful name (e.g., "**/*.ts" → skip, "auth*.ts" → "auth") - PATTERN=$(echo "$RAW" | sed -n 's/.*[*\/]\([a-zA-Z][a-zA-Z0-9_-]*\).*/\1/p') - ;; - Bash) - CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null) - # Only augment grep/rg commands - if echo "$CMD" | grep -qE '\brg\b|\bgrep\b'; then - # Extract pattern from rg/grep - if echo "$CMD" | grep -qE '\brg\b'; then - PATTERN=$(echo "$CMD" | sed -n "s/.*\brg\s\+\(--[^ ]*\s\+\)*['\"]\\?\([^'\";\| >]*\\).*/\2/p") - elif echo "$CMD" | grep -qE '\bgrep\b'; then - PATTERN=$(echo "$CMD" | sed -n "s/.*\bgrep\s\+\(-[^ ]*\s\+\)*['\"]\\?\([^'\";\| >]*\\).*/\2/p") - fi - fi - ;; - *) - # Not a search tool — skip - exit 0 - ;; -esac - -# Skip if pattern too short or empty -if [ -z "$PATTERN" ] || [ ${#PATTERN} -lt 3 ]; then - exit 0 -fi - -# Check if we're in a GitNexus-indexed repo -dir="${CWD:-$PWD}" -found=false -for i in 1 2 3 4 5; do - if [ -d "$dir/.gitnexus" ]; then - found=true - break - fi - parent="$(dirname "$dir")" - [ "$parent" = "$dir" ] && break - dir="$parent" -done - -if [ "$found" = false ]; then - exit 0 -fi - -# Run gitnexus augment — must be fast (<500ms target) -RESULT=$(cd "$CWD" && npx -y gitnexus augment "$PATTERN" 2>/dev/null) - -if [ -n "$RESULT" ]; then - ESCAPED=$(echo "$RESULT" | jq -Rs .) - jq -n --argjson ctx "$ESCAPED" '{ - hookSpecificOutput: { - hookEventName: "PreToolUse", - additionalContext: $ctx - } - }' -else - exit 0 -fi diff --git a/gitnexus-claude-plugin/hooks/session-start.js b/gitnexus-claude-plugin/hooks/session-start.js deleted file mode 100644 index 86157d3545..0000000000 --- a/gitnexus-claude-plugin/hooks/session-start.js +++ /dev/null @@ -1,41 +0,0 @@ -// GitNexus SessionStart hook for Claude Code -// Fires on session startup. Stdout is injected into Claude's context. -// Checks if the current directory has a GitNexus index. - -const fs = require('fs'); -const path = require('path'); - -let dir = process.cwd(); -let found = false; -for (let i = 0; i < 5; i++) { - if (fs.existsSync(path.join(dir, '.gitnexus'))) { - found = true; - break; - } - const parent = path.dirname(dir); - if (parent === dir) break; - dir = parent; -} - -if (!found) { - process.exit(0); -} - -process.stdout.write(`## GitNexus Code Intelligence - -This codebase is indexed by GitNexus, providing a knowledge graph with execution flows, relationships, and semantic search. - -**Available MCP Tools:** -- \`query\` — Process-grouped code intelligence (execution flows related to a concept) -- \`context\` — 360-degree symbol view (categorized refs, process participation) -- \`impact\` — Blast radius analysis (what breaks if you change a symbol) -- \`detect_changes\` — Git-diff impact analysis (what do your changes affect) -- \`rename\` — Multi-file coordinated rename with confidence tags -- \`cypher\` — Raw graph queries -- \`list_repos\` — Discover indexed repos - -**Quick Start:** READ \`gitnexus://repo/{name}/context\` for codebase overview, then use \`query\` to find execution flows. - -**Resources:** \`gitnexus://repo/{name}/context\` (overview), \`/processes\` (execution flows), \`/schema\` (for Cypher) -`); -process.exit(0); diff --git a/gitnexus-claude-plugin/hooks/session-start.sh b/gitnexus-claude-plugin/hooks/session-start.sh deleted file mode 100644 index 8960dd376d..0000000000 --- a/gitnexus-claude-plugin/hooks/session-start.sh +++ /dev/null @@ -1,42 +0,0 @@ -#!/bin/bash -# GitNexus SessionStart hook for Claude Code -# Fires on session startup. Stdout is injected into Claude's context. -# Checks if the current directory has a GitNexus index. - -dir="$PWD" -found=false -for i in 1 2 3 4 5; do - if [ -d "$dir/.gitnexus" ]; then - found=true - break - fi - parent="$(dirname "$dir")" - [ "$parent" = "$dir" ] && break - dir="$parent" -done - -if [ "$found" = false ]; then - exit 0 -fi - -# Inject GitNexus context — this stdout goes directly into Claude's context -cat << 'EOF' -## GitNexus Code Intelligence - -This codebase is indexed by GitNexus, providing a knowledge graph with execution flows, relationships, and semantic search. - -**Available MCP Tools:** -- `query` — Process-grouped code intelligence (execution flows related to a concept) -- `context` — 360-degree symbol view (categorized refs, process participation) -- `impact` — Blast radius analysis (what breaks if you change a symbol) -- `detect_changes` — Git-diff impact analysis (what do your changes affect) -- `rename` — Multi-file coordinated rename with confidence tags -- `cypher` — Raw graph queries -- `list_repos` — Discover indexed repos - -**Quick Start:** READ `gitnexus://repo/{name}/context` for codebase overview, then use `query` to find execution flows. - -**Resources:** `gitnexus://repo/{name}/context` (overview), `/processes` (execution flows), `/schema` (for Cypher) -EOF - -exit 0 diff --git a/gitnexus-claude-plugin/skills/gitnexus-cli/SKILL.md b/gitnexus-claude-plugin/skills/gitnexus-cli/SKILL.md new file mode 100644 index 0000000000..607aa8c4a6 --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-cli/SKILL.md @@ -0,0 +1,82 @@ +--- +name: gitnexus-cli +description: "Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: \"Index this repo\", \"Reanalyze the codebase\", \"Generate a wiki\"" +--- + +# GitNexus CLI Commands + +All commands work via `npx` — no global install required. + +## Commands + +### analyze — Build or refresh the index + +```bash +npx gitnexus analyze +``` + +Run from the project root. This parses all source files, builds the knowledge graph, writes it to `.gitnexus/`, and generates CLAUDE.md / AGENTS.md context files. + +| Flag | Effect | +|------|--------| +| `--force` | Force full re-index even if up to date | +| `--embeddings` | Enable embedding generation for semantic search (off by default) | + +**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale. + +### status — Check index freshness + +```bash +npx gitnexus status +``` + +Shows whether the current repo has a GitNexus index, when it was last updated, and symbol/relationship counts. Use this to check if re-indexing is needed. + +### clean — Delete the index + +```bash +npx gitnexus clean +``` + +Deletes the `.gitnexus/` directory and unregisters the repo from the global registry. Use before re-indexing if the index is corrupt or after removing GitNexus from a project. + +| Flag | Effect | +|------|--------| +| `--force` | Skip confirmation prompt | +| `--all` | Clean all indexed repos, not just the current one | + +### wiki — Generate documentation from the graph + +```bash +npx gitnexus wiki +``` + +Generates repository documentation from the knowledge graph using an LLM. Requires an API key (saved to `~/.gitnexus/config.json` on first use). + +| Flag | Effect | +|------|--------| +| `--force` | Force full regeneration | +| `--model <model>` | LLM model (default: minimax/minimax-m2.5) | +| `--base-url <url>` | LLM API base URL | +| `--api-key <key>` | LLM API key | +| `--concurrency <n>` | Parallel LLM calls (default: 3) | +| `--gist` | Publish wiki as a public GitHub Gist | + +### list — Show all indexed repos + +```bash +npx gitnexus list +``` + +Lists all repositories registered in `~/.gitnexus/registry.json`. The MCP `list_repos` tool provides the same information. + +## After Indexing + +1. **Read `gitnexus://repo/{name}/context`** to verify the index loaded +2. Use the other GitNexus skills (`exploring`, `debugging`, `impact-analysis`, `refactoring`) for your task + +## Troubleshooting + +- **"Not inside a git repository"**: Run from a directory inside a git repo +- **Index is stale after re-analyzing**: Restart Claude Code to reload the MCP server +- **Embeddings slow**: Omit `--embeddings` (it's off by default) or set `OPENAI_API_KEY` for faster API-based embedding diff --git a/gitnexus-claude-plugin/skills/gitnexus-cli/mcp.json b/gitnexus-claude-plugin/skills/gitnexus-cli/mcp.json new file mode 100644 index 0000000000..cd02d4285a --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-cli/mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "gitnexus": { + "command": "npx", + "args": ["-y", "gitnexus@latest", "mcp"] + } + } +} diff --git a/gitnexus-claude-plugin/skills/debugging/SKILL.md b/gitnexus-claude-plugin/skills/gitnexus-debugging/SKILL.md similarity index 76% rename from gitnexus-claude-plugin/skills/debugging/SKILL.md rename to gitnexus-claude-plugin/skills/gitnexus-debugging/SKILL.md index 3b945835bd..9510b97ac3 100644 --- a/gitnexus-claude-plugin/skills/debugging/SKILL.md +++ b/gitnexus-claude-plugin/skills/gitnexus-debugging/SKILL.md @@ -1,11 +1,12 @@ --- name: gitnexus-debugging -description: Trace bugs through call chains using knowledge graph +description: "Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: \"Why is X failing?\", \"Where does this error come from?\", \"Trace this bug\"" --- # Debugging with GitNexus ## When to Use + - "Why is this function failing?" - "Trace where this error comes from" - "Who calls this method?" @@ -37,17 +38,18 @@ description: Trace bugs through call chains using knowledge graph ## Debugging Patterns -| Symptom | GitNexus Approach | -|---------|-------------------| -| Error message | `gitnexus_query` for error text → `context` on throw sites | -| Wrong return value | `context` on the function → trace callees for data flow | -| Intermittent failure | `context` → look for external calls, async deps | -| Performance issue | `context` → find symbols with many callers (hot paths) | -| Recent regression | `detect_changes` to see what your changes affect | +| Symptom | GitNexus Approach | +| -------------------- | ---------------------------------------------------------- | +| Error message | `gitnexus_query` for error text → `context` on throw sites | +| Wrong return value | `context` on the function → trace callees for data flow | +| Intermittent failure | `context` → look for external calls, async deps | +| Performance issue | `context` → find symbols with many callers (hot paths) | +| Recent regression | `detect_changes` to see what your changes affect | ## Tools **gitnexus_query** — find code related to error: + ``` gitnexus_query({query: "payment validation error"}) → Processes: CheckoutFlow, ErrorHandling @@ -55,6 +57,7 @@ gitnexus_query({query: "payment validation error"}) ``` **gitnexus_context** — full context for a suspect: + ``` gitnexus_context({name: "validatePayment"}) → Incoming calls: processCheckout, webhookHandler @@ -63,6 +66,7 @@ gitnexus_context({name: "validatePayment"}) ``` **gitnexus_cypher** — custom call chain traces: + ```cypher MATCH path = (a)-[:CodeRelation {type: 'CALLS'}*1..2]->(b:Function {name: "validatePayment"}) RETURN [n IN nodes(path) | n.name] AS chain diff --git a/gitnexus-claude-plugin/skills/gitnexus-debugging/mcp.json b/gitnexus-claude-plugin/skills/gitnexus-debugging/mcp.json new file mode 100644 index 0000000000..cd02d4285a --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-debugging/mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "gitnexus": { + "command": "npx", + "args": ["-y", "gitnexus@latest", "mcp"] + } + } +} diff --git a/.claude/skills/gitnexus/exploring/SKILL.md b/gitnexus-claude-plugin/skills/gitnexus-exploring/SKILL.md similarity index 75% rename from .claude/skills/gitnexus/exploring/SKILL.md rename to gitnexus-claude-plugin/skills/gitnexus-exploring/SKILL.md index 2214c289cd..927a4e4b64 100644 --- a/.claude/skills/gitnexus/exploring/SKILL.md +++ b/gitnexus-claude-plugin/skills/gitnexus-exploring/SKILL.md @@ -1,11 +1,12 @@ --- name: gitnexus-exploring -description: Navigate unfamiliar code using GitNexus knowledge graph +description: "Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: \"How does X work?\", \"What calls this function?\", \"Show me the auth flow\"" --- # Exploring Codebases with GitNexus ## When to Use + - "How does authentication work?" - "What's the project structure?" - "Show me the main components" @@ -37,16 +38,17 @@ description: Navigate unfamiliar code using GitNexus knowledge graph ## Resources -| Resource | What you get | -|----------|-------------| -| `gitnexus://repo/{name}/context` | Stats, staleness warning (~150 tokens) | -| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores (~300 tokens) | -| `gitnexus://repo/{name}/cluster/{name}` | Area members with file paths (~500 tokens) | -| `gitnexus://repo/{name}/process/{name}` | Step-by-step execution trace (~200 tokens) | +| Resource | What you get | +| --------------------------------------- | ------------------------------------------------------- | +| `gitnexus://repo/{name}/context` | Stats, staleness warning (~150 tokens) | +| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores (~300 tokens) | +| `gitnexus://repo/{name}/cluster/{name}` | Area members with file paths (~500 tokens) | +| `gitnexus://repo/{name}/process/{name}` | Step-by-step execution trace (~200 tokens) | ## Tools **gitnexus_query** — find execution flows related to a concept: + ``` gitnexus_query({query: "payment processing"}) → Processes: CheckoutFlow, RefundFlow, WebhookHandler @@ -54,6 +56,7 @@ gitnexus_query({query: "payment processing"}) ``` **gitnexus_context** — 360-degree view of a symbol: + ``` gitnexus_context({name: "validateUser"}) → Incoming calls: loginHandler, apiMiddleware diff --git a/gitnexus-claude-plugin/skills/gitnexus-exploring/mcp.json b/gitnexus-claude-plugin/skills/gitnexus-exploring/mcp.json new file mode 100644 index 0000000000..cd02d4285a --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-exploring/mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "gitnexus": { + "command": "npx", + "args": ["-y", "gitnexus@latest", "mcp"] + } + } +} diff --git a/gitnexus-claude-plugin/skills/gitnexus-guide/SKILL.md b/gitnexus-claude-plugin/skills/gitnexus-guide/SKILL.md new file mode 100644 index 0000000000..937ac73d16 --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-guide/SKILL.md @@ -0,0 +1,64 @@ +--- +name: gitnexus-guide +description: "Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: \"What GitNexus tools are available?\", \"How do I use GitNexus?\"" +--- + +# GitNexus Guide + +Quick reference for all GitNexus MCP tools, resources, and the knowledge graph schema. + +## Always Start Here + +For any task involving code understanding, debugging, impact analysis, or refactoring: + +1. **Read `gitnexus://repo/{name}/context`** — codebase overview + check index freshness +2. **Match your task to a skill below** and **read that skill file** +3. **Follow the skill's workflow and checklist** + +> If step 1 warns the index is stale, run `npx gitnexus analyze` in the terminal first. + +## Skills + +| Task | Skill to read | +| -------------------------------------------- | ------------------- | +| Understand architecture / "How does X work?" | `gitnexus-exploring` | +| Blast radius / "What breaks if I change X?" | `gitnexus-impact-analysis` | +| Trace bugs / "Why is X failing?" | `gitnexus-debugging` | +| Rename / extract / split / refactor | `gitnexus-refactoring` | +| Tools, resources, schema reference | `gitnexus-guide` (this file) | +| Index, status, clean, wiki CLI commands | `gitnexus-cli` | + +## Tools Reference + +| Tool | What it gives you | +| ---------------- | ------------------------------------------------------------------------ | +| `query` | Process-grouped code intelligence — execution flows related to a concept | +| `context` | 360-degree symbol view — categorized refs, processes it participates in | +| `impact` | Symbol blast radius — what breaks at depth 1/2/3 with confidence | +| `detect_changes` | Git-diff impact — what do your current changes affect | +| `rename` | Multi-file coordinated rename with confidence-tagged edits | +| `cypher` | Raw graph queries (read `gitnexus://repo/{name}/schema` first) | +| `list_repos` | Discover indexed repos | + +## Resources Reference + +Lightweight reads (~100-500 tokens) for navigation: + +| Resource | Content | +| ---------------------------------------------- | ----------------------------------------- | +| `gitnexus://repo/{name}/context` | Stats, staleness check | +| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores | +| `gitnexus://repo/{name}/cluster/{clusterName}` | Area members | +| `gitnexus://repo/{name}/processes` | All execution flows | +| `gitnexus://repo/{name}/process/{processName}` | Step-by-step trace | +| `gitnexus://repo/{name}/schema` | Graph schema for Cypher | + +## Graph Schema + +**Nodes:** File, Function, Class, Interface, Method, Community, Process +**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS + +```cypher +MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"}) +RETURN caller.name, caller.filePath +``` diff --git a/gitnexus-claude-plugin/skills/gitnexus-guide/mcp.json b/gitnexus-claude-plugin/skills/gitnexus-guide/mcp.json new file mode 100644 index 0000000000..cd02d4285a --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-guide/mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "gitnexus": { + "command": "npx", + "args": ["-y", "gitnexus@latest", "mcp"] + } + } +} diff --git a/.claude/skills/gitnexus/impact-analysis/SKILL.md b/gitnexus-claude-plugin/skills/gitnexus-impact-analysis/SKILL.md similarity index 74% rename from .claude/skills/gitnexus/impact-analysis/SKILL.md rename to gitnexus-claude-plugin/skills/gitnexus-impact-analysis/SKILL.md index bb5f51fcc1..e19af280c1 100644 --- a/.claude/skills/gitnexus/impact-analysis/SKILL.md +++ b/gitnexus-claude-plugin/skills/gitnexus-impact-analysis/SKILL.md @@ -1,11 +1,12 @@ --- name: gitnexus-impact-analysis -description: Analyze blast radius before making code changes +description: "Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: \"Is it safe to change X?\", \"What depends on this?\", \"What will break?\"" --- # Impact Analysis with GitNexus ## When to Use + - "Is it safe to change this function?" - "What will break if I modify X?" - "Show me the blast radius" @@ -37,24 +38,25 @@ description: Analyze blast radius before making code changes ## Understanding Output -| Depth | Risk Level | Meaning | -|-------|-----------|---------| -| d=1 | **WILL BREAK** | Direct callers/importers | -| d=2 | LIKELY AFFECTED | Indirect dependencies | -| d=3 | MAY NEED TESTING | Transitive effects | +| Depth | Risk Level | Meaning | +| ----- | ---------------- | ------------------------ | +| d=1 | **WILL BREAK** | Direct callers/importers | +| d=2 | LIKELY AFFECTED | Indirect dependencies | +| d=3 | MAY NEED TESTING | Transitive effects | ## Risk Assessment -| Affected | Risk | -|----------|------| -| <5 symbols, few processes | LOW | -| 5-15 symbols, 2-5 processes | MEDIUM | -| >15 symbols or many processes | HIGH | +| Affected | Risk | +| ------------------------------ | -------- | +| <5 symbols, few processes | LOW | +| 5-15 symbols, 2-5 processes | MEDIUM | +| >15 symbols or many processes | HIGH | | Critical path (auth, payments) | CRITICAL | ## Tools **gitnexus_impact** — the primary tool for symbol blast radius: + ``` gitnexus_impact({ target: "validateUser", @@ -72,6 +74,7 @@ gitnexus_impact({ ``` **gitnexus_detect_changes** — git-diff based impact analysis: + ``` gitnexus_detect_changes({scope: "staged"}) diff --git a/gitnexus-claude-plugin/skills/gitnexus-impact-analysis/mcp.json b/gitnexus-claude-plugin/skills/gitnexus-impact-analysis/mcp.json new file mode 100644 index 0000000000..cd02d4285a --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-impact-analysis/mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "gitnexus": { + "command": "npx", + "args": ["-y", "gitnexus@latest", "mcp"] + } + } +} diff --git a/gitnexus-claude-plugin/skills/gitnexus-pr-review/SKILL.md b/gitnexus-claude-plugin/skills/gitnexus-pr-review/SKILL.md new file mode 100644 index 0000000000..e112f47baa --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-pr-review/SKILL.md @@ -0,0 +1,163 @@ +--- +name: gitnexus-pr-review +description: "Use when the user wants to review a pull request, understand what a PR changes, assess risk of merging, or check for missing test coverage. Examples: \"Review this PR\", \"What does PR #42 change?\", \"Is this PR safe to merge?\"" +--- + +# PR Review with GitNexus + +## When to Use + +- "Review this PR" +- "What does PR #42 change?" +- "Is this safe to merge?" +- "What's the blast radius of this PR?" +- "Are there missing tests for this PR?" +- Reviewing someone else's code changes before merge + +## Workflow + +``` +1. gh pr diff <number> → Get the raw diff +2. gitnexus_detect_changes({scope: "compare", base_ref: "main"}) → Map diff to affected flows +3. For each changed symbol: + gitnexus_impact({target: "<symbol>", direction: "upstream"}) → Blast radius per change +4. gitnexus_context({name: "<key symbol>"}) → Understand callers/callees +5. READ gitnexus://repo/{name}/processes → Check affected execution flows +6. Summarize findings with risk assessment +``` + +> If "Index is stale" → run `npx gitnexus analyze` in terminal before reviewing. + +## Checklist + +``` +- [ ] Fetch PR diff (gh pr diff or git diff base...head) +- [ ] gitnexus_detect_changes to map changes to affected execution flows +- [ ] gitnexus_impact on each non-trivial changed symbol +- [ ] Review d=1 items (WILL BREAK) — are callers updated? +- [ ] gitnexus_context on key changed symbols to understand full picture +- [ ] Check if affected processes have test coverage +- [ ] Assess overall risk level +- [ ] Write review summary with findings +``` + +## Review Dimensions + +| Dimension | How GitNexus Helps | +| --- | --- | +| **Correctness** | `context` shows callers — are they all compatible with the change? | +| **Blast radius** | `impact` shows d=1/d=2/d=3 dependents — anything missed? | +| **Completeness** | `detect_changes` shows all affected flows — are they all handled? | +| **Test coverage** | `impact({includeTests: true})` shows which tests touch changed code | +| **Breaking changes** | d=1 upstream items that aren't updated in the PR = potential breakage | + +## Risk Assessment + +| Signal | Risk | +| --- | --- | +| Changes touch <3 symbols, 0-1 processes | LOW | +| Changes touch 3-10 symbols, 2-5 processes | MEDIUM | +| Changes touch >10 symbols or many processes | HIGH | +| Changes touch auth, payments, or data integrity code | CRITICAL | +| d=1 callers exist outside the PR diff | Potential breakage — flag it | + +## Tools + +**gitnexus_detect_changes** — map PR diff to affected execution flows: + +``` +gitnexus_detect_changes({scope: "compare", base_ref: "main"}) + +→ Changed: 8 symbols in 4 files +→ Affected processes: CheckoutFlow, RefundFlow, WebhookHandler +→ Risk: MEDIUM +``` + +**gitnexus_impact** — blast radius per changed symbol: + +``` +gitnexus_impact({target: "validatePayment", direction: "upstream"}) + +→ d=1 (WILL BREAK): + - processCheckout (src/checkout.ts:42) [CALLS, 100%] + - webhookHandler (src/webhooks.ts:15) [CALLS, 100%] + +→ d=2 (LIKELY AFFECTED): + - checkoutRouter (src/routes/checkout.ts:22) [CALLS, 95%] +``` + +**gitnexus_impact with tests** — check test coverage: + +``` +gitnexus_impact({target: "validatePayment", direction: "upstream", includeTests: true}) + +→ Tests that cover this symbol: + - validatePayment.test.ts [direct] + - checkout.integration.test.ts [via processCheckout] +``` + +**gitnexus_context** — understand a changed symbol's role: + +``` +gitnexus_context({name: "validatePayment"}) + +→ Incoming calls: processCheckout, webhookHandler +→ Outgoing calls: verifyCard, fetchRates +→ Processes: CheckoutFlow (step 3/7), RefundFlow (step 1/5) +``` + +## Example: "Review PR #42" + +``` +1. gh pr diff 42 > /tmp/pr42.diff + → 4 files changed: payments.ts, checkout.ts, types.ts, utils.ts + +2. gitnexus_detect_changes({scope: "compare", base_ref: "main"}) + → Changed symbols: validatePayment, PaymentInput, formatAmount + → Affected processes: CheckoutFlow, RefundFlow + → Risk: MEDIUM + +3. gitnexus_impact({target: "validatePayment", direction: "upstream"}) + → d=1: processCheckout, webhookHandler (WILL BREAK) + → webhookHandler is NOT in the PR diff — potential breakage! + +4. gitnexus_impact({target: "PaymentInput", direction: "upstream"}) + → d=1: validatePayment (in PR), createPayment (NOT in PR) + → createPayment uses the old PaymentInput shape — breaking change! + +5. gitnexus_context({name: "formatAmount"}) + → Called by 12 functions — but change is backwards-compatible (added optional param) + +6. Review summary: + - MEDIUM risk — 3 changed symbols affect 2 execution flows + - BUG: webhookHandler calls validatePayment but isn't updated for new signature + - BUG: createPayment depends on PaymentInput type which changed + - OK: formatAmount change is backwards-compatible + - Tests: checkout.test.ts covers processCheckout path, but no webhook test +``` + +## Review Output Format + +Structure your review as: + +```markdown +## PR Review: <title> + +**Risk: LOW / MEDIUM / HIGH / CRITICAL** + +### Changes Summary +- <N> symbols changed across <M> files +- <P> execution flows affected + +### Findings +1. **[severity]** Description of finding + - Evidence from GitNexus tools + - Affected callers/flows + +### Missing Coverage +- Callers not updated in PR: ... +- Untested flows: ... + +### Recommendation +APPROVE / REQUEST CHANGES / NEEDS DISCUSSION +``` diff --git a/gitnexus-claude-plugin/skills/refactoring/SKILL.md b/gitnexus-claude-plugin/skills/gitnexus-refactoring/SKILL.md similarity index 84% rename from gitnexus-claude-plugin/skills/refactoring/SKILL.md rename to gitnexus-claude-plugin/skills/gitnexus-refactoring/SKILL.md index 23f4d11301..f48cc01bd5 100644 --- a/gitnexus-claude-plugin/skills/refactoring/SKILL.md +++ b/gitnexus-claude-plugin/skills/gitnexus-refactoring/SKILL.md @@ -1,11 +1,12 @@ --- name: gitnexus-refactoring -description: Plan safe refactors using blast radius and dependency mapping +description: "Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: \"Rename this function\", \"Extract this into a module\", \"Refactor this class\", \"Move this to a separate file\"" --- # Refactoring with GitNexus ## When to Use + - "Rename this function safely" - "Extract this into a module" - "Split this service" @@ -26,6 +27,7 @@ description: Plan safe refactors using blast radius and dependency mapping ## Checklists ### Rename Symbol + ``` - [ ] gitnexus_rename({symbol_name: "oldName", new_name: "newName", dry_run: true}) — preview all edits - [ ] Review graph edits (high confidence) and ast_search edits (review carefully) @@ -35,6 +37,7 @@ description: Plan safe refactors using blast radius and dependency mapping ``` ### Extract Module + ``` - [ ] gitnexus_context({name: target}) — see all incoming/outgoing refs - [ ] gitnexus_impact({target, direction: "upstream"}) — find all external callers @@ -45,6 +48,7 @@ description: Plan safe refactors using blast radius and dependency mapping ``` ### Split Function/Service + ``` - [ ] gitnexus_context({name: target}) — understand all callees - [ ] Group callees by responsibility @@ -58,6 +62,7 @@ description: Plan safe refactors using blast radius and dependency mapping ## Tools **gitnexus_rename** — automated multi-file rename: + ``` gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true}) → 12 edits across 8 files @@ -66,6 +71,7 @@ gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_ ``` **gitnexus_impact** — map all dependents first: + ``` gitnexus_impact({target: "validateUser", direction: "upstream"}) → d=1: loginHandler, apiMiddleware, testUtils @@ -73,6 +79,7 @@ gitnexus_impact({target: "validateUser", direction: "upstream"}) ``` **gitnexus_detect_changes** — verify your changes after refactoring: + ``` gitnexus_detect_changes({scope: "all"}) → Changed: 8 files, 12 symbols @@ -81,6 +88,7 @@ gitnexus_detect_changes({scope: "all"}) ``` **gitnexus_cypher** — custom reference queries: + ```cypher MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "validateUser"}) RETURN caller.name, caller.filePath ORDER BY caller.filePath @@ -88,12 +96,12 @@ RETURN caller.name, caller.filePath ORDER BY caller.filePath ## Risk Rules -| Risk Factor | Mitigation | -|-------------|------------| -| Many callers (>5) | Use gitnexus_rename for automated updates | -| Cross-area refs | Use detect_changes after to verify scope | -| String/dynamic refs | gitnexus_query to find them | -| External/public API | Version and deprecate properly | +| Risk Factor | Mitigation | +| ------------------- | ----------------------------------------- | +| Many callers (>5) | Use gitnexus_rename for automated updates | +| Cross-area refs | Use detect_changes after to verify scope | +| String/dynamic refs | gitnexus_query to find them | +| External/public API | Version and deprecate properly | ## Example: Rename `validateUser` to `authenticateUser` diff --git a/gitnexus-claude-plugin/skills/gitnexus-refactoring/mcp.json b/gitnexus-claude-plugin/skills/gitnexus-refactoring/mcp.json new file mode 100644 index 0000000000..cd02d4285a --- /dev/null +++ b/gitnexus-claude-plugin/skills/gitnexus-refactoring/mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "gitnexus": { + "command": "npx", + "args": ["-y", "gitnexus@latest", "mcp"] + } + } +} diff --git a/gitnexus-cursor-integration/skills/gitnexus-pr-review/SKILL.md b/gitnexus-cursor-integration/skills/gitnexus-pr-review/SKILL.md new file mode 100644 index 0000000000..e112f47baa --- /dev/null +++ b/gitnexus-cursor-integration/skills/gitnexus-pr-review/SKILL.md @@ -0,0 +1,163 @@ +--- +name: gitnexus-pr-review +description: "Use when the user wants to review a pull request, understand what a PR changes, assess risk of merging, or check for missing test coverage. Examples: \"Review this PR\", \"What does PR #42 change?\", \"Is this PR safe to merge?\"" +--- + +# PR Review with GitNexus + +## When to Use + +- "Review this PR" +- "What does PR #42 change?" +- "Is this safe to merge?" +- "What's the blast radius of this PR?" +- "Are there missing tests for this PR?" +- Reviewing someone else's code changes before merge + +## Workflow + +``` +1. gh pr diff <number> → Get the raw diff +2. gitnexus_detect_changes({scope: "compare", base_ref: "main"}) → Map diff to affected flows +3. For each changed symbol: + gitnexus_impact({target: "<symbol>", direction: "upstream"}) → Blast radius per change +4. gitnexus_context({name: "<key symbol>"}) → Understand callers/callees +5. READ gitnexus://repo/{name}/processes → Check affected execution flows +6. Summarize findings with risk assessment +``` + +> If "Index is stale" → run `npx gitnexus analyze` in terminal before reviewing. + +## Checklist + +``` +- [ ] Fetch PR diff (gh pr diff or git diff base...head) +- [ ] gitnexus_detect_changes to map changes to affected execution flows +- [ ] gitnexus_impact on each non-trivial changed symbol +- [ ] Review d=1 items (WILL BREAK) — are callers updated? +- [ ] gitnexus_context on key changed symbols to understand full picture +- [ ] Check if affected processes have test coverage +- [ ] Assess overall risk level +- [ ] Write review summary with findings +``` + +## Review Dimensions + +| Dimension | How GitNexus Helps | +| --- | --- | +| **Correctness** | `context` shows callers — are they all compatible with the change? | +| **Blast radius** | `impact` shows d=1/d=2/d=3 dependents — anything missed? | +| **Completeness** | `detect_changes` shows all affected flows — are they all handled? | +| **Test coverage** | `impact({includeTests: true})` shows which tests touch changed code | +| **Breaking changes** | d=1 upstream items that aren't updated in the PR = potential breakage | + +## Risk Assessment + +| Signal | Risk | +| --- | --- | +| Changes touch <3 symbols, 0-1 processes | LOW | +| Changes touch 3-10 symbols, 2-5 processes | MEDIUM | +| Changes touch >10 symbols or many processes | HIGH | +| Changes touch auth, payments, or data integrity code | CRITICAL | +| d=1 callers exist outside the PR diff | Potential breakage — flag it | + +## Tools + +**gitnexus_detect_changes** — map PR diff to affected execution flows: + +``` +gitnexus_detect_changes({scope: "compare", base_ref: "main"}) + +→ Changed: 8 symbols in 4 files +→ Affected processes: CheckoutFlow, RefundFlow, WebhookHandler +→ Risk: MEDIUM +``` + +**gitnexus_impact** — blast radius per changed symbol: + +``` +gitnexus_impact({target: "validatePayment", direction: "upstream"}) + +→ d=1 (WILL BREAK): + - processCheckout (src/checkout.ts:42) [CALLS, 100%] + - webhookHandler (src/webhooks.ts:15) [CALLS, 100%] + +→ d=2 (LIKELY AFFECTED): + - checkoutRouter (src/routes/checkout.ts:22) [CALLS, 95%] +``` + +**gitnexus_impact with tests** — check test coverage: + +``` +gitnexus_impact({target: "validatePayment", direction: "upstream", includeTests: true}) + +→ Tests that cover this symbol: + - validatePayment.test.ts [direct] + - checkout.integration.test.ts [via processCheckout] +``` + +**gitnexus_context** — understand a changed symbol's role: + +``` +gitnexus_context({name: "validatePayment"}) + +→ Incoming calls: processCheckout, webhookHandler +→ Outgoing calls: verifyCard, fetchRates +→ Processes: CheckoutFlow (step 3/7), RefundFlow (step 1/5) +``` + +## Example: "Review PR #42" + +``` +1. gh pr diff 42 > /tmp/pr42.diff + → 4 files changed: payments.ts, checkout.ts, types.ts, utils.ts + +2. gitnexus_detect_changes({scope: "compare", base_ref: "main"}) + → Changed symbols: validatePayment, PaymentInput, formatAmount + → Affected processes: CheckoutFlow, RefundFlow + → Risk: MEDIUM + +3. gitnexus_impact({target: "validatePayment", direction: "upstream"}) + → d=1: processCheckout, webhookHandler (WILL BREAK) + → webhookHandler is NOT in the PR diff — potential breakage! + +4. gitnexus_impact({target: "PaymentInput", direction: "upstream"}) + → d=1: validatePayment (in PR), createPayment (NOT in PR) + → createPayment uses the old PaymentInput shape — breaking change! + +5. gitnexus_context({name: "formatAmount"}) + → Called by 12 functions — but change is backwards-compatible (added optional param) + +6. Review summary: + - MEDIUM risk — 3 changed symbols affect 2 execution flows + - BUG: webhookHandler calls validatePayment but isn't updated for new signature + - BUG: createPayment depends on PaymentInput type which changed + - OK: formatAmount change is backwards-compatible + - Tests: checkout.test.ts covers processCheckout path, but no webhook test +``` + +## Review Output Format + +Structure your review as: + +```markdown +## PR Review: <title> + +**Risk: LOW / MEDIUM / HIGH / CRITICAL** + +### Changes Summary +- <N> symbols changed across <M> files +- <P> execution flows affected + +### Findings +1. **[severity]** Description of finding + - Evidence from GitNexus tools + - Affected callers/flows + +### Missing Coverage +- Callers not updated in PR: ... +- Untested flows: ... + +### Recommendation +APPROVE / REQUEST CHANGES / NEEDS DISCUSSION +``` diff --git a/gitnexus-web/package-lock.json b/gitnexus-web/package-lock.json index 97942ca4d2..dd7bce991b 100644 --- a/gitnexus-web/package-lock.json +++ b/gitnexus-web/package-lock.json @@ -10,6 +10,7 @@ "dependencies": { "@huggingface/transformers": "^3.0.0", "@isomorphic-git/lightning-fs": "^4.6.2", + "@ladybugdb/wasm-core": "^0.15.1", "@langchain/anthropic": "^1.3.10", "@langchain/core": "^1.1.15", "@langchain/google-genai": "^2.1.10", @@ -30,7 +31,6 @@ "graphology-utils": "^2.3.0", "isomorphic-git": "^1.36.1", "jszip": "^3.10.1", - "kuzu-wasm": "^0.11.1", "langchain": "^1.2.10", "lru-cache": "^11.2.4", "lucide-react": "^0.562.0", @@ -1643,6 +1643,30 @@ "@jridgewell/sourcemap-codec": "^1.4.14" } }, + "node_modules/@ladybugdb/wasm-core": { + "version": "0.15.1", + "resolved": "https://registry.npmjs.org/@ladybugdb/wasm-core/-/wasm-core-0.15.1.tgz", + "integrity": "sha512-dHEq8inJQBkHnJrqZMKGdltSfeSv9OHECkzWQixqDLApXXGlbJ5Ugq5rRfk2PLJuZ74LVHT0cZvcn4JLmsnAIA==", + "license": "MIT", + "dependencies": { + "threads": "^1.7.0", + "tiny-worker": "^2.3.0", + "uuid": "^11.0.3" + } + }, + "node_modules/@ladybugdb/wasm-core/node_modules/uuid": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", + "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "bin": { + "uuid": "dist/esm/bin/uuid" + } + }, "node_modules/@langchain/anthropic": { "version": "1.3.10", "resolved": "https://registry.npmjs.org/@langchain/anthropic/-/anthropic-1.3.10.tgz", @@ -6194,31 +6218,6 @@ "resolved": "https://registry.npmjs.org/khroma/-/khroma-2.1.0.tgz", "integrity": "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw==" }, - "node_modules/kuzu-wasm": { - "version": "0.11.3", - "resolved": "https://registry.npmjs.org/kuzu-wasm/-/kuzu-wasm-0.11.3.tgz", - "integrity": "sha512-+bLOqXgYZJJ2dHJG1y9LTLyb9ZB73eLxErRZahZz2rPokfIdyLaktTJFzJH7wX39hgyukKn8QxeRNobH6gl27g==", - "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.", - "license": "MIT", - "dependencies": { - "threads": "^1.7.0", - "tiny-worker": "^2.3.0", - "uuid": "^11.0.3" - } - }, - "node_modules/kuzu-wasm/node_modules/uuid": { - "version": "11.1.0", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", - "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", - "funding": [ - "https://github.com/sponsors/broofa", - "https://github.com/sponsors/ctavan" - ], - "license": "MIT", - "bin": { - "uuid": "dist/esm/bin/uuid" - } - }, "node_modules/langchain": { "version": "1.2.10", "resolved": "https://registry.npmjs.org/langchain/-/langchain-1.2.10.tgz", diff --git a/gitnexus-web/package.json b/gitnexus-web/package.json index d66c421132..f20e0b35de 100644 --- a/gitnexus-web/package.json +++ b/gitnexus-web/package.json @@ -33,7 +33,7 @@ "graphology-layout-noverlap": "^0.4.2", "isomorphic-git": "^1.36.1", "jszip": "^3.10.1", - "kuzu-wasm": "^0.11.1", + "@ladybugdb/wasm-core": "^0.15.2", "langchain": "^1.2.10", "lru-cache": "^11.2.4", "lucide-react": "^0.562.0", diff --git a/gitnexus-web/public/wasm/kuzu-wasm.wasm b/gitnexus-web/public/wasm/kuzu-wasm.wasm deleted file mode 100644 index d7d0f7fced..0000000000 Binary files a/gitnexus-web/public/wasm/kuzu-wasm.wasm and /dev/null differ diff --git a/gitnexus-web/public/wasm/php/tree-sitter-php.wasm b/gitnexus-web/public/wasm/php/tree-sitter-php.wasm new file mode 100644 index 0000000000..12f3c445c0 Binary files /dev/null and b/gitnexus-web/public/wasm/php/tree-sitter-php.wasm differ diff --git a/gitnexus-web/public/wasm/ruby/tree-sitter-ruby.wasm b/gitnexus-web/public/wasm/ruby/tree-sitter-ruby.wasm new file mode 100644 index 0000000000..c7a619c96c Binary files /dev/null and b/gitnexus-web/public/wasm/ruby/tree-sitter-ruby.wasm differ diff --git a/gitnexus-web/public/wasm/swift/tree-sitter-swift.wasm b/gitnexus-web/public/wasm/swift/tree-sitter-swift.wasm new file mode 100755 index 0000000000..87282f2164 Binary files /dev/null and b/gitnexus-web/public/wasm/swift/tree-sitter-swift.wasm differ diff --git a/gitnexus-web/src/App.tsx b/gitnexus-web/src/App.tsx index 6cb18cc3c3..2de2a4a34a 100644 --- a/gitnexus-web/src/App.tsx +++ b/gitnexus-web/src/App.tsx @@ -1,4 +1,4 @@ -import { useCallback, useRef } from 'react'; +import { useCallback, useEffect, useRef } from 'react'; import { AppStateProvider, useAppState } from './hooks/useAppState'; import { DropZone } from './components/DropZone'; import { LoadingOverlay } from './components/LoadingOverlay'; @@ -11,9 +11,8 @@ import { FileTreePanel } from './components/FileTreePanel'; import { CodeReferencesPanel } from './components/CodeReferencesPanel'; import { FileEntry } from './services/zip'; import { getActiveProviderConfig } from './core/llm/settings-service'; -import { useBackend } from './hooks/useBackend'; -import { fetchGraph } from './services/backend'; import { createKnowledgeGraph } from './core/graph/graph'; +import { connectToServer, fetchRepos, normalizeServerUrl, type ConnectToServerResult } from './services/server-connection'; const AppContent = () => { const { @@ -36,12 +35,13 @@ const AppContent = () => { codeReferences, selectedNode, isCodePanelOpen, - setBackendMode, - setBackendRepo, + serverBaseUrl, + setServerBaseUrl, + availableRepos, + setAvailableRepos, + switchRepo, } = useAppState(); - const backend = useBackend(); - const graphCanvasRef = useRef<GraphCanvasHandle>(null); const handleFileSelect = useCallback(async (file: File) => { @@ -132,63 +132,105 @@ const AppContent = () => { } }, [setViewMode, setGraph, setFileContents, setProgress, setProjectName, runPipelineFromFiles, startEmbeddings, initializeAgent]); - const handleFocusNode = useCallback((nodeId: string) => { - graphCanvasRef.current?.focusNode(nodeId); - }, []); + const handleServerConnect = useCallback((result: ConnectToServerResult) => { + // Extract project name from repoPath + const repoPath = result.repoInfo.repoPath; + const projectName = repoPath.split('/').pop() || 'server-project'; + setProjectName(projectName); - const handleSelectBackendRepo = useCallback(async (repoName: string) => { + // Build KnowledgeGraph from server data (bypasses WASM pipeline entirely) + const graph = createKnowledgeGraph(); + for (const node of result.nodes) { + graph.addNode(node); + } + for (const rel of result.relationships) { + graph.addRelationship(rel); + } + setGraph(graph); + + // Set file contents from extracted File node content + const fileMap = new Map<string, string>(); + for (const [path, content] of Object.entries(result.fileContents)) { + fileMap.set(path, content); + } + setFileContents(fileMap); + + // Transition directly to exploring view + setViewMode('exploring'); + + // Initialize agent if LLM is configured + if (getActiveProviderConfig()) { + initializeAgent(projectName); + } + + // Auto-start embeddings + startEmbeddings().catch((err) => { + if (err?.name === 'WebGPUNotAvailableError' || err?.message?.includes('WebGPU')) { + startEmbeddings('wasm').catch(console.warn); + } else { + console.warn('Embeddings auto-start failed:', err); + } + }); + }, [setViewMode, setGraph, setFileContents, setProjectName, initializeAgent, startEmbeddings]); + + // Auto-connect when ?server query param is present (bookmarkable shortcut) + const autoConnectRan = useRef(false); + useEffect(() => { + if (autoConnectRan.current) return; + const params = new URLSearchParams(window.location.search); + if (!params.has('server')) return; + autoConnectRan.current = true; + + // Clean the URL so a refresh won't re-trigger + const cleanUrl = window.location.pathname + window.location.hash; + window.history.replaceState(null, '', cleanUrl); + + setProgress({ phase: 'extracting', percent: 0, message: 'Connecting to server...', detail: 'Validating server' }); setViewMode('loading'); - setProjectName(repoName); - setProgress({ phase: 'extracting', percent: 50, message: 'Loading from server...', detail: 'Fetching graph data' }); - try { - const graphData = await fetchGraph(repoName); + const serverUrl = params.get('server') || window.location.origin; - // Build KnowledgeGraph from server data - const graph = createKnowledgeGraph(); - for (const node of graphData.nodes) { - graph.addNode(node as any); + const baseUrl = normalizeServerUrl(serverUrl); + + connectToServer(serverUrl, (phase, downloaded, total) => { + if (phase === 'validating') { + setProgress({ phase: 'extracting', percent: 5, message: 'Connecting to server...', detail: 'Validating server' }); + } else if (phase === 'downloading') { + const pct = total ? Math.round((downloaded / total) * 90) + 5 : 50; + const mb = (downloaded / (1024 * 1024)).toFixed(1); + setProgress({ phase: 'extracting', percent: pct, message: 'Downloading graph...', detail: `${mb} MB downloaded` }); + } else if (phase === 'extracting') { + setProgress({ phase: 'extracting', percent: 97, message: 'Processing...', detail: 'Extracting file contents' }); } - for (const rel of graphData.relationships) { - graph.addRelationship(rel as any); - } - setGraph(graph); + }).then(async (result) => { + handleServerConnect(result); - // Extract file contents from File nodes (content is in node properties) - const contents = new Map<string, string>(); - for (const node of graphData.nodes) { - const n = node as any; - if (n.label === 'File' && n.properties?.content && n.properties?.filePath) { - contents.set(n.properties.filePath, n.properties.content); - } + // Store server URL and fetch available repos for the repo switcher + setServerBaseUrl(baseUrl); + try { + const repos = await fetchRepos(baseUrl); + setAvailableRepos(repos); + } catch (e) { + console.warn('Failed to fetch repo list:', e); } - setFileContents(contents); - - // Enter backend mode - setBackendMode(true); - setBackendRepo(repoName); - backend.selectRepo(repoName); - setProgress(null); - setViewMode('exploring'); - - // Initialize agent if LLM configured - if (getActiveProviderConfig()) { - initializeAgent(repoName); - } - } catch (error) { - console.error('Backend load error:', error); + }).catch((err) => { + console.error('Auto-connect failed:', err); setProgress({ phase: 'error', percent: 0, - message: 'Error loading from server', - detail: error instanceof Error ? error.message : 'Unknown error', + message: 'Failed to connect to server', + detail: err instanceof Error ? err.message : 'Unknown error', }); setTimeout(() => { setViewMode('onboarding'); setProgress(null); }, 3000); - } - }, [setViewMode, setGraph, setFileContents, setProgress, setProjectName, setBackendMode, setBackendRepo, backend, initializeAgent]); + }); + }, [handleServerConnect, setProgress, setViewMode, setServerBaseUrl, setAvailableRepos]); + + const handleFocusNode = useCallback((nodeId: string) => { + graphCanvasRef.current?.focusNode(nodeId); + }, []); // Handle settings saved - refresh and reinitialize agent // NOTE: Must be defined BEFORE any conditional returns (React hooks rule) @@ -203,10 +245,19 @@ const AppContent = () => { <DropZone onFileSelect={handleFileSelect} onGitClone={handleGitClone} - backendRepos={backend.repos} - isBackendConnected={backend.isConnected} - backendUrl={backend.backendUrl} - onSelectBackendRepo={handleSelectBackendRepo} + onServerConnect={async (result, serverUrl) => { + handleServerConnect(result); + if (serverUrl) { + const baseUrl = normalizeServerUrl(serverUrl); + setServerBaseUrl(baseUrl); + try { + const repos = await fetchRepos(baseUrl); + setAvailableRepos(repos); + } catch (e) { + console.warn('Failed to fetch repo list:', e); + } + } + }} /> ); } @@ -218,7 +269,7 @@ const AppContent = () => { // Exploring view return ( <div className="flex flex-col h-screen bg-void overflow-hidden"> - <Header onFocusNode={handleFocusNode} /> + <Header onFocusNode={handleFocusNode} availableRepos={availableRepos} onSwitchRepo={switchRepo} /> <main className="flex-1 flex min-h-0"> {/* Left Panel - File Tree */} @@ -247,9 +298,6 @@ const AppContent = () => { isOpen={isSettingsPanelOpen} onClose={() => setSettingsPanelOpen(false)} onSettingsSaved={handleSettingsSaved} - backendUrl={backend.backendUrl} - isBackendConnected={backend.isConnected} - onBackendUrlChange={backend.setBackendUrl} /> </div> diff --git a/gitnexus-web/src/components/CodeReferencesPanel.tsx b/gitnexus-web/src/components/CodeReferencesPanel.tsx index 4bda5cca05..021ccd9022 100644 --- a/gitnexus-web/src/components/CodeReferencesPanel.tsx +++ b/gitnexus-web/src/components/CodeReferencesPanel.tsx @@ -5,6 +5,42 @@ import { vscDarkPlus } from 'react-syntax-highlighter/dist/esm/styles/prism'; import { useAppState } from '../hooks/useAppState'; import { NODE_COLORS } from '../lib/constants'; +/** Map file extension to Prism syntax highlighter language identifier */ +const getSyntaxLanguage = (filePath: string | undefined): string => { + if (!filePath) return 'text'; + const ext = filePath.split('.').pop()?.toLowerCase(); + switch (ext) { + case 'js': case 'jsx': case 'mjs': case 'cjs': return 'javascript'; + case 'ts': case 'tsx': case 'mts': case 'cts': return 'typescript'; + case 'py': case 'pyw': return 'python'; + case 'rb': case 'rake': case 'gemspec': return 'ruby'; + case 'java': return 'java'; + case 'go': return 'go'; + case 'rs': return 'rust'; + case 'c': case 'h': return 'c'; + case 'cpp': case 'cc': case 'cxx': case 'hpp': case 'hxx': case 'hh': return 'cpp'; + case 'cs': return 'csharp'; + case 'php': return 'php'; + case 'kt': case 'kts': return 'kotlin'; + case 'swift': return 'swift'; + case 'json': return 'json'; + case 'yaml': case 'yml': return 'yaml'; + case 'md': case 'mdx': return 'markdown'; + case 'html': case 'htm': case 'erb': return 'markup'; + case 'css': case 'scss': case 'sass': return 'css'; + case 'sh': case 'bash': case 'zsh': return 'bash'; + case 'sql': return 'sql'; + case 'xml': return 'xml'; + default: break; + } + // Handle extensionless Ruby files + const basename = filePath.split('/').pop() || ''; + if (['Rakefile', 'Gemfile', 'Guardfile', 'Vagrantfile', 'Brewfile'].includes(basename)) return 'ruby'; + if (['Makefile'].includes(basename)) return 'makefile'; + if (['Dockerfile'].includes(basename)) return 'docker'; + return 'text'; +}; + // Match the code theme used elsewhere in the app const customTheme = { ...vscDarkPlus, @@ -267,12 +303,7 @@ export const CodeReferencesPanel = ({ onFocusNode }: CodeReferencesPanelProps) = <div className="flex-1 min-h-0 overflow-auto scrollbar-thin"> {selectedFileContent ? ( <SyntaxHighlighter - language={ - selectedFilePath?.endsWith('.py') ? 'python' : - selectedFilePath?.endsWith('.js') || selectedFilePath?.endsWith('.jsx') ? 'javascript' : - selectedFilePath?.endsWith('.ts') || selectedFilePath?.endsWith('.tsx') ? 'typescript' : - 'text' - } + language={getSyntaxLanguage(selectedFilePath)} style={customTheme as any} showLineNumbers startingLineNumber={1} @@ -339,11 +370,7 @@ export const CodeReferencesPanel = ({ onFocusNode }: CodeReferencesPanelProps) = const hasRange = typeof ref.startLine === 'number'; const startDisplay = hasRange ? (ref.startLine ?? 0) + 1 : undefined; const endDisplay = hasRange ? (ref.endLine ?? ref.startLine ?? 0) + 1 : undefined; - const language = - ref.filePath.endsWith('.py') ? 'python' : - ref.filePath.endsWith('.js') || ref.filePath.endsWith('.jsx') ? 'javascript' : - ref.filePath.endsWith('.ts') || ref.filePath.endsWith('.tsx') ? 'typescript' : - 'text'; + const language = getSyntaxLanguage(ref.filePath); const isGlowing = glowRefId === ref.id; diff --git a/gitnexus-web/src/components/DropZone.tsx b/gitnexus-web/src/components/DropZone.tsx index dc3c82e2ab..fa78576683 100644 --- a/gitnexus-web/src/components/DropZone.tsx +++ b/gitnexus-web/src/components/DropZone.tsx @@ -1,22 +1,24 @@ -import { useState, useCallback, useEffect, useRef, DragEvent } from 'react'; -import { Upload, FileArchive, Github, Loader2, ArrowRight, Key, Eye, EyeOff, Server } from 'lucide-react'; +import { useState, useCallback, useRef, DragEvent } from 'react'; +import { Upload, FileArchive, Github, Loader2, ArrowRight, Key, Eye, EyeOff, Globe, X } from 'lucide-react'; import { cloneRepository, parseGitHubUrl } from '../services/git-clone'; +import { connectToServer, type ConnectToServerResult } from '../services/server-connection'; import { FileEntry } from '../services/zip'; -import { BackendRepo } from '../services/backend'; -import { BackendRepoSelector } from './BackendRepoSelector'; interface DropZoneProps { onFileSelect: (file: File) => void; onGitClone?: (files: FileEntry[]) => void; - backendRepos?: BackendRepo[]; - isBackendConnected?: boolean; - backendUrl?: string; - onSelectBackendRepo?: (repoName: string) => void; + onServerConnect?: (result: ConnectToServerResult, serverUrl?: string) => void; } -export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConnected, backendUrl, onSelectBackendRepo }: DropZoneProps) => { +function formatBytes(bytes: number): string { + if (bytes < 1024) return `${bytes} B`; + if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`; + return `${(bytes / (1024 * 1024)).toFixed(1)} MB`; +} + +export const DropZone = ({ onFileSelect, onGitClone, onServerConnect }: DropZoneProps) => { const [isDragging, setIsDragging] = useState(false); - const [activeTab, setActiveTab] = useState<'zip' | 'github' | 'local'>('zip'); + const [activeTab, setActiveTab] = useState<'zip' | 'github' | 'server'>('zip'); const [githubUrl, setGithubUrl] = useState(''); const [githubToken, setGithubToken] = useState(''); const [showToken, setShowToken] = useState(false); @@ -24,13 +26,17 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn const [cloneProgress, setCloneProgress] = useState({ phase: '', percent: 0 }); const [error, setError] = useState<string | null>(null); - const hasAutoSwitched = useRef(false); - useEffect(() => { - if (!hasAutoSwitched.current && isBackendConnected && backendRepos && backendRepos.length > 0) { - setActiveTab('local'); - hasAutoSwitched.current = true; - } - }, [isBackendConnected, backendRepos]); + // Server tab state + const [serverUrl, setServerUrl] = useState(() => + localStorage.getItem('gitnexus-server-url') || '' + ); + const [isConnecting, setIsConnecting] = useState(false); + const [serverProgress, setServerProgress] = useState<{ + phase: string; + downloaded: number; + total: number | null; + }>({ phase: '', downloaded: 0, total: null }); + const abortControllerRef = useRef<AbortController | null>(null); const handleDragOver = useCallback((e: DragEvent<HTMLDivElement>) => { e.preventDefault(); @@ -92,10 +98,9 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn const files = await cloneRepository( githubUrl, (phase, percent) => setCloneProgress({ phase, percent }), - githubToken || undefined // Pass token if provided + githubToken || undefined ); - // Clear token from memory after successful clone setGithubToken(''); if (onGitClone) { @@ -104,12 +109,11 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn } catch (err) { console.error('Clone failed:', err); const message = err instanceof Error ? err.message : 'Failed to clone repository'; - // Provide helpful error for auth failures if (message.includes('401') || message.includes('403') || message.includes('Authentication')) { if (!githubToken) { - setError('🔒 This looks like a private repo. Add a GitHub PAT (Personal Access Token) to access it.'); + setError('This looks like a private repo. Add a GitHub PAT (Personal Access Token) to access it.'); } else { - setError('🔑 Authentication failed. Check your token permissions (needs repo access).'); + setError('Authentication failed. Check your token permissions (needs repo access).'); } } else if (message.includes('404') || message.includes('not found')) { setError('Repository not found. Check the URL or it might be private (needs PAT).'); @@ -121,6 +125,62 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn } }; + const handleServerConnect = async () => { + const urlToUse = serverUrl.trim() || window.location.origin; + if (!urlToUse) { + setError('Please enter a server URL'); + return; + } + + // Persist URL to localStorage + localStorage.setItem('gitnexus-server-url', serverUrl); + + setError(null); + setIsConnecting(true); + setServerProgress({ phase: 'validating', downloaded: 0, total: null }); + + const abortController = new AbortController(); + abortControllerRef.current = abortController; + + try { + const result = await connectToServer( + urlToUse, + (phase, downloaded, total) => { + setServerProgress({ phase, downloaded, total }); + }, + abortController.signal + ); + + if (onServerConnect) { + onServerConnect(result, urlToUse); + } + } catch (err) { + if ((err as Error).name === 'AbortError') { + // User cancelled + return; + } + console.error('Server connect failed:', err); + const message = err instanceof Error ? err.message : 'Failed to connect to server'; + if (message.includes('Failed to fetch') || message.includes('NetworkError')) { + setError('Cannot reach server. Check the URL and ensure the server is running.'); + } else { + setError(message); + } + } finally { + setIsConnecting(false); + abortControllerRef.current = null; + } + }; + + const handleCancelConnect = () => { + abortControllerRef.current?.abort(); + setIsConnecting(false); + }; + + const serverProgressPercent = serverProgress.total + ? Math.round((serverProgress.downloaded / serverProgress.total) * 100) + : null; + return ( <div className="flex items-center justify-center min-h-screen p-8 bg-void"> {/* Background gradient effects */} @@ -161,25 +221,18 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn GitHub URL </button> <button - onClick={() => { setActiveTab('local'); setError(null); }} + onClick={() => { setActiveTab('server'); setError(null); }} className={` flex-1 flex items-center justify-center gap-2 py-2.5 px-4 rounded-lg text-sm font-medium transition-all duration-200 - ${activeTab === 'local' + ${activeTab === 'server' ? 'bg-accent text-white shadow-md' - : isBackendConnected - ? 'text-text-secondary hover:text-text-primary hover:bg-elevated' - : 'text-text-muted cursor-not-allowed opacity-50' + : 'text-text-secondary hover:text-text-primary hover:bg-elevated' } `} - disabled={!isBackendConnected} - title={!isBackendConnected ? 'Start gitnexus serve to connect' : undefined} > - <Server className="w-4 h-4" /> - Local Server - {isBackendConnected && ( - <span className="w-1.5 h-1.5 bg-green-400 rounded-full" /> - )} + <Globe className="w-4 h-4" /> + Server </button> </div> @@ -195,7 +248,7 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn <> <div className={` - relative p-16 + relative p-16 bg-surface border-2 border-dashed rounded-3xl transition-all duration-300 cursor-pointer ${isDragging @@ -282,7 +335,7 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn data-1p-ignore="true" data-form-type="other" className=" - w-full px-4 py-3 + w-full px-4 py-3 bg-elevated border border-border-default rounded-xl text-text-primary placeholder-text-muted focus:outline-none focus:border-accent focus:ring-1 focus:ring-accent @@ -308,7 +361,7 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn data-1p-ignore="true" data-form-type="other" className=" - w-full pl-10 pr-10 py-3 + w-full pl-10 pr-10 py-3 bg-elevated border border-border-default rounded-xl text-text-primary placeholder-text-muted focus:outline-none focus:border-accent focus:ring-1 focus:ring-accent @@ -329,9 +382,9 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn onClick={handleGitClone} disabled={isCloning || !githubUrl.trim()} className=" - w-full flex items-center justify-center gap-2 - px-4 py-3 - bg-accent hover:bg-accent/90 + w-full flex items-center justify-center gap-2 + px-4 py-3 + bg-accent hover:bg-accent/90 text-white font-medium rounded-xl disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200 @@ -371,7 +424,7 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn {/* Security note */} {githubToken && ( <p className="mt-3 text-xs text-text-muted text-center"> - 🔒 Token stays in your browser only, never sent to any server + Token stays in your browser only, never sent to any server </p> )} @@ -387,14 +440,131 @@ export const DropZone = ({ onFileSelect, onGitClone, backendRepos, isBackendConn </div> )} - {/* Local Server Tab */} - {activeTab === 'local' && isBackendConnected && backendRepos && onSelectBackendRepo && ( - <BackendRepoSelector - repos={backendRepos} - onSelectRepo={onSelectBackendRepo} - backendUrl={backendUrl ?? 'http://localhost:4747'} - isConnected={isBackendConnected} - /> + {/* Server Tab */} + {activeTab === 'server' && ( + <div className="p-8 bg-surface border border-border-default rounded-3xl"> + {/* Icon */} + <div className="mx-auto w-20 h-20 mb-6 flex items-center justify-center bg-gradient-to-br from-accent to-emerald-600 rounded-2xl shadow-lg"> + <Globe className="w-10 h-10 text-white" /> + </div> + + {/* Text */} + <h2 className="text-xl font-semibold text-text-primary text-center mb-2"> + Connect to Server + </h2> + <p className="text-sm text-text-secondary text-center mb-6"> + Load a pre-built knowledge graph from a running GitNexus server + </p> + + {/* Inputs */} + <div className="space-y-3" data-form-type="other"> + <input + type="url" + name="server-url-input" + value={serverUrl} + onChange={(e) => setServerUrl(e.target.value)} + onKeyDown={(e) => e.key === 'Enter' && !isConnecting && handleServerConnect()} + placeholder={window.location.origin} + disabled={isConnecting} + autoComplete="off" + data-lpignore="true" + data-1p-ignore="true" + data-form-type="other" + className=" + w-full px-4 py-3 + bg-elevated border border-border-default rounded-xl + text-text-primary placeholder-text-muted + focus:outline-none focus:border-accent focus:ring-1 focus:ring-accent + disabled:opacity-50 disabled:cursor-not-allowed + transition-all duration-200 + " + /> + + <div className="flex gap-2"> + <button + onClick={handleServerConnect} + disabled={isConnecting} + className=" + flex-1 flex items-center justify-center gap-2 + px-4 py-3 + bg-accent hover:bg-accent/90 + text-white font-medium rounded-xl + disabled:opacity-50 disabled:cursor-not-allowed + transition-all duration-200 + " + > + {isConnecting ? ( + <> + <Loader2 className="w-5 h-5 animate-spin" /> + {serverProgress.phase === 'validating' + ? 'Validating...' + : serverProgress.phase === 'downloading' + ? serverProgressPercent !== null + ? `Downloading... ${serverProgressPercent}%` + : `Downloading... ${formatBytes(serverProgress.downloaded)}` + : serverProgress.phase === 'extracting' + ? 'Processing...' + : 'Connecting...' + } + </> + ) : ( + <> + Connect + <ArrowRight className="w-5 h-5" /> + </> + )} + </button> + + {isConnecting && ( + <button + onClick={handleCancelConnect} + className=" + flex items-center justify-center + px-4 py-3 + bg-red-500/20 hover:bg-red-500/30 + text-red-400 font-medium rounded-xl + transition-all duration-200 + " + > + <X className="w-5 h-5" /> + </button> + )} + </div> + </div> + + {/* Progress bar */} + {isConnecting && serverProgress.phase === 'downloading' && ( + <div className="mt-4"> + <div className="h-2 bg-elevated rounded-full overflow-hidden"> + <div + className={`h-full bg-accent transition-all duration-300 ease-out ${ + serverProgressPercent === null ? 'animate-pulse' : '' + }`} + style={{ + width: serverProgressPercent !== null + ? `${serverProgressPercent}%` + : '100%', + }} + /> + </div> + {serverProgress.total && ( + <p className="mt-1 text-xs text-text-muted text-center"> + {formatBytes(serverProgress.downloaded)} / {formatBytes(serverProgress.total)} + </p> + )} + </div> + )} + + {/* Hints */} + <div className="mt-4 flex items-center justify-center gap-3 text-xs text-text-muted"> + <span className="px-3 py-1.5 bg-elevated border border-border-subtle rounded-md"> + Pre-indexed + </span> + <span className="px-3 py-1.5 bg-elevated border border-border-subtle rounded-md"> + No WASM needed + </span> + </div> + </div> )} </div> </div> diff --git a/gitnexus-web/src/components/EmbeddingStatus.tsx b/gitnexus-web/src/components/EmbeddingStatus.tsx index ab706b99a3..4bf6001c90 100644 --- a/gitnexus-web/src/components/EmbeddingStatus.tsx +++ b/gitnexus-web/src/components/EmbeddingStatus.tsx @@ -14,7 +14,7 @@ export const EmbeddingStatus = () => { startEmbeddings, graph, viewMode, - isBackendMode, + serverBaseUrl, testArrayParams, } = useAppState(); @@ -22,7 +22,7 @@ export const EmbeddingStatus = () => { const [showFallbackDialog, setShowFallbackDialog] = useState(false); // Only show when exploring a loaded graph; hide in backend mode (no WASM DB) - if (viewMode !== 'exploring' || !graph || isBackendMode) return null; + if (viewMode !== 'exploring' || !graph || serverBaseUrl) return null; const nodeCount = graph.nodes.length; @@ -83,7 +83,7 @@ export const EmbeddingStatus = () => { <button onClick={handleTestArrayParams} className="flex items-center gap-1 px-2 py-1.5 bg-surface border border-border-subtle rounded-lg text-xs text-text-muted hover:bg-hover hover:text-text-secondary transition-all" - title="Test if KuzuDB supports array params" + title="Test if LadybugDB supports array params" > <FlaskConical className="w-3 h-3" /> {testResult || 'Test'} diff --git a/gitnexus-web/src/components/Header.tsx b/gitnexus-web/src/components/Header.tsx index 465a6b9d88..64edd0077b 100644 --- a/gitnexus-web/src/components/Header.tsx +++ b/gitnexus-web/src/components/Header.tsx @@ -1,5 +1,6 @@ -import { Search, Settings, HelpCircle, Sparkles, Github, Star } from 'lucide-react'; +import { Search, Settings, HelpCircle, Sparkles, Github, Star, ChevronDown } from 'lucide-react'; import { useAppState } from '../hooks/useAppState'; +import type { RepoSummary } from '../services/server-connection'; import { useState, useMemo, useRef, useEffect, useCallback } from 'react'; import { GraphNode } from '../core/graph/types'; import { EmbeddingStatus } from './EmbeddingStatus'; @@ -19,9 +20,11 @@ const NODE_TYPE_COLORS: Record<string, string> = { interface HeaderProps { onFocusNode?: (nodeId: string) => void; + availableRepos?: RepoSummary[]; + onSwitchRepo?: (repoName: string) => void; } -export const Header = ({ onFocusNode }: HeaderProps) => { +export const Header = ({ onFocusNode, availableRepos = [], onSwitchRepo }: HeaderProps) => { const { projectName, graph, @@ -29,8 +32,9 @@ export const Header = ({ onFocusNode }: HeaderProps) => { isRightPanelOpen, rightPanelTab, setSettingsPanelOpen, - isBackendMode, } = useAppState(); + const [isRepoDropdownOpen, setIsRepoDropdownOpen] = useState(false); + const repoDropdownRef = useRef<HTMLDivElement>(null); const [searchQuery, setSearchQuery] = useState(''); const [isSearchOpen, setIsSearchOpen] = useState(false); const [selectedIndex, setSelectedIndex] = useState(0); @@ -50,12 +54,15 @@ export const Header = ({ onFocusNode }: HeaderProps) => { .slice(0, 10); // Limit to 10 results }, [graph, searchQuery]); - // Handle clicking outside to close dropdown + // Handle clicking outside to close dropdowns useEffect(() => { const handleClickOutside = (e: MouseEvent) => { if (searchRef.current && !searchRef.current.contains(e.target as Node)) { setIsSearchOpen(false); } + if (repoDropdownRef.current && !repoDropdownRef.current.contains(e.target as Node)) { + setIsRepoDropdownOpen(false); + } }; document.addEventListener('mousedown', handleClickOutside); return () => document.removeEventListener('mousedown', handleClickOutside); @@ -117,18 +124,50 @@ export const Header = ({ onFocusNode }: HeaderProps) => { <span className="font-semibold text-[15px] tracking-tight">GitNexus</span> </div> - {/* Project badge */} + {/* Project badge / Repo selector dropdown */} {projectName && ( - <div className="flex items-center gap-2 px-3 py-1.5 bg-surface border border-border-subtle rounded-lg text-sm text-text-secondary"> - <span className="w-1.5 h-1.5 bg-node-function rounded-full animate-pulse" /> - <span className="truncate max-w-[200px]">{projectName}</span> - </div> - )} + <div className="relative" ref={repoDropdownRef}> + <button + onClick={() => availableRepos.length >= 2 && setIsRepoDropdownOpen(prev => !prev)} + className={`flex items-center gap-2 px-3 py-1.5 bg-surface border border-border-subtle rounded-lg text-sm text-text-secondary transition-colors ${availableRepos.length >= 2 ? 'hover:bg-hover cursor-pointer' : ''}`} + > + <span className="w-1.5 h-1.5 bg-node-function rounded-full animate-pulse" /> + <span className="truncate max-w-[200px]">{projectName}</span> + {availableRepos.length >= 2 && ( + <ChevronDown className={`w-3.5 h-3.5 text-text-muted transition-transform ${isRepoDropdownOpen ? 'rotate-180' : ''}`} /> + )} + </button> - {isBackendMode && ( - <div className="flex items-center gap-1.5 px-2.5 py-1 bg-green-500/10 border border-green-500/30 rounded-lg text-xs text-green-400"> - <span className="w-1.5 h-1.5 bg-green-400 rounded-full animate-pulse" /> - Local + {/* Repo dropdown */} + {isRepoDropdownOpen && availableRepos.length >= 2 && ( + <div className="absolute top-full left-0 mt-1 w-72 bg-surface border border-border-subtle rounded-lg shadow-xl overflow-hidden z-50"> + {availableRepos.map((repo) => { + const isCurrent = repo.name === projectName; + return ( + <button + key={repo.name} + onClick={() => { + if (!isCurrent && onSwitchRepo) { + onSwitchRepo(repo.name); + } + setIsRepoDropdownOpen(false); + }} + className={`w-full px-4 py-3 flex items-center gap-3 text-left transition-colors ${isCurrent ? 'bg-accent/10 border-l-2 border-accent' : 'hover:bg-hover border-l-2 border-transparent'}`} + > + <span className={`w-2 h-2 rounded-full flex-shrink-0 ${isCurrent ? 'bg-node-function animate-pulse' : 'bg-text-muted'}`} /> + <div className="flex-1 min-w-0"> + <div className={`text-sm font-medium truncate ${isCurrent ? 'text-accent' : 'text-text-primary'}`}> + {repo.name} + </div> + <div className="text-xs text-text-muted mt-0.5"> + {repo.stats?.nodes ?? '?'} nodes · {repo.stats?.files ?? '?'} files + </div> + </div> + </button> + ); + })} + </div> + )} </div> )} </div> diff --git a/gitnexus-web/src/components/MarkdownRenderer.tsx b/gitnexus-web/src/components/MarkdownRenderer.tsx index db9081af09..77f6e6f8df 100644 --- a/gitnexus-web/src/components/MarkdownRenderer.tsx +++ b/gitnexus-web/src/components/MarkdownRenderer.tsx @@ -1,10 +1,11 @@ -import React from 'react'; +import React, { useState } from 'react'; import ReactMarkdown from 'react-markdown'; import remarkGfm from 'remark-gfm'; import { Prism as SyntaxHighlighter } from 'react-syntax-highlighter'; import { vscDarkPlus } from 'react-syntax-highlighter/dist/esm/styles/prism'; import { MermaidDiagram } from './MermaidDiagram'; import { ToolCallCard } from './ToolCallCard'; +import { Copy, Check } from 'lucide-react'; // Custom syntax theme const customTheme = { @@ -28,13 +29,26 @@ interface MarkdownRendererProps { content: string; onLinkClick?: (href: string) => void; toolCalls?: any[]; // Keep flexible for now + showCopyButton?: boolean; } export const MarkdownRenderer: React.FC<MarkdownRendererProps> = ({ content, onLinkClick, - toolCalls + toolCalls, + showCopyButton = false }) => { + const [copied, setCopied] = useState(false); + + const handleCopy = async () => { + try { + await navigator.clipboard.writeText(content); + setCopied(true); + setTimeout(() => setCopied(false), 2000); + } catch (err) { + console.error('Failed to copy:', err); + } + }; // Helper to format text for display (convert [[links]] to markdown links) const formatMarkdownForDisplay = (md: string) => { @@ -166,6 +180,20 @@ export const MarkdownRenderer: React.FC<MarkdownRendererProps> = ({ {formattedContent} </ReactMarkdown> + {/* Copy Button */} + {showCopyButton && ( + <div className="mt-2 flex justify-end"> + <button + onClick={handleCopy} + className="flex items-center gap-1.5 px-2 py-1 text-xs text-text-muted hover:text-text-primary hover:bg-surface border border-transparent hover:border-border-subtle rounded transition-all" + title="Copy to clipboard" + > + {copied ? <Check className="w-3.5 h-3.5 text-emerald-400" /> : <Copy className="w-3.5 h-3.5" />} + <span>{copied ? 'Copied' : 'Copy'}</span> + </button> + </div> + )} + {/* Tool Call Cards appended at the bottom if provided */} {toolCalls && toolCalls.length > 0 && ( <div className="mt-3 space-y-2"> diff --git a/gitnexus-web/src/components/RightPanel.tsx b/gitnexus-web/src/components/RightPanel.tsx index 1f27fc9174..84be0f7385 100644 --- a/gitnexus-web/src/components/RightPanel.tsx +++ b/gitnexus-web/src/components/RightPanel.tsx @@ -345,7 +345,7 @@ export const RightPanel = () => { {/* Render steps in order (reasoning, tool calls, content interleaved) */} {message.steps && message.steps.length > 0 ? ( <div className="space-y-4"> - {message.steps.map((step) => ( + {message.steps.map((step, index) => ( <div key={step.id}> {step.type === 'reasoning' && step.content && ( <div className="text-text-secondary text-sm italic border-l-2 border-text-muted/30 pl-3 mb-3"> @@ -364,6 +364,7 @@ export const RightPanel = () => { <MarkdownRenderer content={step.content} onLinkClick={handleLinkClick} + showCopyButton={index === message.steps!.length - 1} /> )} </div> @@ -375,6 +376,7 @@ export const RightPanel = () => { content={message.content} onLinkClick={handleLinkClick} toolCalls={message.toolCalls} + showCopyButton={true} /> )} </div> diff --git a/gitnexus-web/src/config/supported-languages.ts b/gitnexus-web/src/config/supported-languages.ts index 15df37c547..4c51b56abc 100644 --- a/gitnexus-web/src/config/supported-languages.ts +++ b/gitnexus-web/src/config/supported-languages.ts @@ -8,7 +8,8 @@ export enum SupportedLanguages { CSharp = 'csharp', Go = 'go', Rust = 'rust', - // PHP = 'php', - // Ruby = 'ruby', - // Swift = 'swift', + PHP = 'php', + Ruby = 'ruby', + Kotlin = 'kotlin', + Swift = 'swift', } \ No newline at end of file diff --git a/gitnexus-web/src/core/embeddings/embedder.ts b/gitnexus-web/src/core/embeddings/embedder.ts index 1188945835..56cbc1fb8f 100644 --- a/gitnexus-web/src/core/embeddings/embedder.ts +++ b/gitnexus-web/src/core/embeddings/embedder.ts @@ -275,7 +275,7 @@ export const embedBatch = async (texts: string[]): Promise<Float32Array[]> => { }; /** - * Convert Float32Array to regular number array (for KuzuDB storage) + * Convert Float32Array to regular number array (for LadybugDB storage) */ export const embeddingToArray = (embedding: Float32Array): number[] => { return Array.from(embedding); diff --git a/gitnexus-web/src/core/embeddings/embedding-pipeline.ts b/gitnexus-web/src/core/embeddings/embedding-pipeline.ts index 05f8ae7edf..ea4756da2c 100644 --- a/gitnexus-web/src/core/embeddings/embedding-pipeline.ts +++ b/gitnexus-web/src/core/embeddings/embedding-pipeline.ts @@ -2,10 +2,10 @@ * Embedding Pipeline Module * * Orchestrates the background embedding process: - * 1. Query embeddable nodes from KuzuDB + * 1. Query embeddable nodes from LadybugDB * 2. Generate text representations * 3. Batch embed using transformers.js - * 4. Update KuzuDB with embeddings + * 4. Update LadybugDB with embeddings * 5. Create vector index for semantic search */ @@ -27,7 +27,7 @@ import { export type EmbeddingProgressCallback = (progress: EmbeddingProgress) => void; /** - * Query all embeddable nodes from KuzuDB + * Query all embeddable nodes from LadybugDB * Uses table-specific queries (File has different schema than code elements) */ const queryEmbeddableNodes = async ( @@ -102,9 +102,23 @@ const batchInsertEmbeddings = async ( * Create the vector index for semantic search * Now indexes the separate CodeEmbedding table */ +let vectorExtensionLoaded = false; + const createVectorIndex = async ( executeQuery: (cypher: string) => Promise<any[]> ): Promise<void> => { + // LadybugDB v0.15+ requires explicit VECTOR extension loading (once per session) + if (!vectorExtensionLoaded) { + try { + await executeQuery('INSTALL VECTOR'); + await executeQuery('LOAD EXTENSION VECTOR'); + vectorExtensionLoaded = true; + } catch { + // Extension may already be loaded — CREATE_VECTOR_INDEX will fail clearly if not + vectorExtensionLoaded = true; + } + } + const cypher = ` CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine') `; @@ -122,7 +136,7 @@ const createVectorIndex = async ( /** * Run the embedding pipeline * - * @param executeQuery - Function to execute Cypher queries against KuzuDB + * @param executeQuery - Function to execute Cypher queries against LadybugDB * @param executeWithReusedStatement - Function to execute with reused prepared statement * @param onProgress - Callback for progress updates * @param config - Optional configuration override @@ -206,7 +220,7 @@ export const runEmbeddingPipeline = async ( // Embed the batch const embeddings = await embedBatch(texts); - // Update KuzuDB with embeddings + // Update LadybugDB with embeddings const updates = batch.map((node, i) => ({ id: node.id, embedding: embeddingToArray(embeddings[i]), @@ -313,51 +327,64 @@ export const semanticSearch = async ( return []; } - // Get metadata for each result by querying each node table - const results: SemanticSearchResult[] = []; - + // Group results by label for batched metadata queries + const byLabel = new Map<string, Array<{ nodeId: string; distance: number }>>(); for (const embRow of embResults) { const nodeId = embRow.nodeId ?? embRow[0]; const distance = embRow.distance ?? embRow[1]; - - // Extract label from node ID (format: Label:path:name) const labelEndIdx = nodeId.indexOf(':'); const label = labelEndIdx > 0 ? nodeId.substring(0, labelEndIdx) : 'Unknown'; - - // Query the specific table for this node - // File nodes don't have startLine/endLine + if (!byLabel.has(label)) byLabel.set(label, []); + byLabel.get(label)!.push({ nodeId, distance }); + } + + // Batch-fetch metadata per label + const results: SemanticSearchResult[] = []; + + for (const [label, items] of byLabel) { + const idList = items.map(i => `'${i.nodeId.replace(/'/g, "''")}'`).join(', '); try { let nodeQuery: string; if (label === 'File') { nodeQuery = ` - MATCH (n:File {id: '${nodeId.replace(/'/g, "''")}'}) - RETURN n.name AS name, n.filePath AS filePath + MATCH (n:File) WHERE n.id IN [${idList}] + RETURN n.id AS id, n.name AS name, n.filePath AS filePath `; } else { nodeQuery = ` - MATCH (n:${label} {id: '${nodeId.replace(/'/g, "''")}'}) - RETURN n.name AS name, n.filePath AS filePath, + MATCH (n:${label}) WHERE n.id IN [${idList}] + RETURN n.id AS id, n.name AS name, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine `; } const nodeRows = await executeQuery(nodeQuery); - if (nodeRows.length > 0) { - const nodeRow = nodeRows[0]; - results.push({ - nodeId, - name: nodeRow.name ?? nodeRow[0] ?? '', - label, - filePath: nodeRow.filePath ?? nodeRow[1] ?? '', - distance, - startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[2]) : undefined, - endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[3]) : undefined, - }); + const rowMap = new Map<string, any>(); + for (const row of nodeRows) { + const id = row.id ?? row[0]; + rowMap.set(id, row); + } + for (const item of items) { + const nodeRow = rowMap.get(item.nodeId); + if (nodeRow) { + results.push({ + nodeId: item.nodeId, + name: nodeRow.name ?? nodeRow[1] ?? '', + label, + filePath: nodeRow.filePath ?? nodeRow[2] ?? '', + distance: item.distance, + startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[3]) : undefined, + endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[4]) : undefined, + }); + } } } catch { // Table might not exist, skip } } + // Re-sort by distance since batch queries may have mixed order + results.sort((a, b) => a.distance - b.distance); + return results; }; diff --git a/gitnexus-web/src/core/embeddings/types.ts b/gitnexus-web/src/core/embeddings/types.ts index e4a04222b2..6d048dfcf5 100644 --- a/gitnexus-web/src/core/embeddings/types.ts +++ b/gitnexus-web/src/core/embeddings/types.ts @@ -92,7 +92,7 @@ export interface SemanticSearchResult { } /** - * Node data for embedding (minimal structure from KuzuDB query) + * Node data for embedding (minimal structure from LadybugDB query) */ export interface EmbeddableNode { id: string; diff --git a/gitnexus-web/src/core/graph/types.ts b/gitnexus-web/src/core/graph/types.ts index 7bc9a5a95f..ceff9f51bf 100644 --- a/gitnexus-web/src/core/graph/types.ts +++ b/gitnexus-web/src/core/graph/types.ts @@ -54,6 +54,7 @@ export type RelationshipType = | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' + | 'HAS_METHOD' | 'MEMBER_OF' | 'STEP_IN_PROCESS' diff --git a/gitnexus-web/src/core/ingestion/call-processor.ts b/gitnexus-web/src/core/ingestion/call-processor.ts index 2b71c5aaa0..c3c17452f2 100644 --- a/gitnexus-web/src/core/ingestion/call-processor.ts +++ b/gitnexus-web/src/core/ingestion/call-processor.ts @@ -6,6 +6,7 @@ import { loadParser, loadLanguage } from '../tree-sitter/parser-loader'; import { LANGUAGE_QUERIES } from './tree-sitter-queries'; import { generateId } from '../../lib/utils'; import { getLanguageFromFilename } from './utils'; +import { callRouters } from './call-routing'; /** * Node types that represent function/method definitions across languages. @@ -35,6 +36,9 @@ const FUNCTION_NODE_TYPES = new Set([ // Rust 'function_item', 'impl_item', // Methods inside impl blocks + // Ruby + 'method', // def foo + 'singleton_method', // def self.foo ]); /** @@ -92,6 +96,18 @@ const findEnclosingFunction = ( current.children?.find((c: any) => c.type === 'identifier'); funcName = nameNode?.text; label = 'Method'; // Treat constructors as methods for process detection + } else if (current.type === 'method') { + // Ruby instance method: def foo + const nameNode = current.childForFieldName?.('name') || + current.children?.find((c: any) => c.type === 'identifier'); + funcName = nameNode?.text; + label = 'Method'; + } else if (current.type === 'singleton_method') { + // Ruby class method: def self.foo + const nameNode = current.childForFieldName?.('name') || + current.children?.find((c: any) => c.type === 'identifier'); + funcName = nameNode?.text; + label = 'Method'; } else if (current.type === 'arrow_function' || current.type === 'function_expression') { // Arrow/expression: const foo = () => {} - check parent variable declarator const parent = current.parent; @@ -126,6 +142,47 @@ const findEnclosingFunction = ( return null; // Top-level call (not inside any function) }; +/** AST node types that represent a class-like container */ +const CLASS_CONTAINER_TYPES = new Set([ + 'class_declaration', 'abstract_class_declaration', + 'interface_declaration', 'struct_declaration', 'record_declaration', + 'class_specifier', 'struct_specifier', + 'impl_item', 'trait_item', + 'class_definition', + 'trait_declaration', + 'protocol_declaration', + 'class', 'module', // Ruby +]); + +const CONTAINER_TYPE_TO_LABEL: Record<string, string> = { + class_declaration: 'Class', abstract_class_declaration: 'Class', + interface_declaration: 'Interface', + struct_declaration: 'Struct', struct_specifier: 'Struct', + class_specifier: 'Class', class_definition: 'Class', + impl_item: 'Impl', trait_item: 'Trait', trait_declaration: 'Trait', + record_declaration: 'Record', protocol_declaration: 'Interface', + class: 'Class', module: 'Module', +}; + +/** Walk up AST to find enclosing class/struct/interface, return its generateId or null. */ +const findEnclosingClassId = (node: any, filePath: string): string | null => { + let current = node.parent; + while (current) { + if (CLASS_CONTAINER_TYPES.has(current.type)) { + const nameNode = current.childForFieldName?.('name') + ?? current.children?.find((c: any) => + c.type === 'type_identifier' || c.type === 'identifier' || c.type === 'name' || c.type === 'constant' + ); + if (nameNode) { + const label = CONTAINER_TYPE_TO_LABEL[current.type] || 'Class'; + return generateId(label, `${filePath}:${nameNode.text}`); + } + } + current = current.parent; + } + return null; +}; + export const processCalls = async ( graph: KnowledgeGraph, files: { path: string; content: string }[], @@ -171,6 +228,8 @@ export const processCalls = async ( continue; } + const callRouter = callRouters[language]; + // 3. Process each call match matches.forEach(match => { const captureMap: Record<string, any> = {}; @@ -184,6 +243,68 @@ export const processCalls = async ( const calledName = nameNode.text; + // Dispatch: route language-specific calls (heritage, properties, imports) + const routed = callRouter(calledName, captureMap['call']); + if (routed) { + switch (routed.kind) { + case 'skip': + case 'import': // handled by import-processor + return; + + case 'heritage': + for (const item of routed.items) { + const childId = symbolTable.lookupExact(file.path, item.enclosingClass) || + symbolTable.lookupFuzzy(item.enclosingClass)[0]?.nodeId || + generateId('Class', `${file.path}:${item.enclosingClass}`); + const parentId = symbolTable.lookupFuzzy(item.mixinName)[0]?.nodeId || + generateId('Module', `${item.mixinName}`); + if (childId && parentId) { + const relId = generateId('IMPLEMENTS', `${childId}->${parentId}:${item.heritageKind}`); + graph.addRelationship({ + id: relId, sourceId: childId, targetId: parentId, + type: 'IMPLEMENTS', confidence: 1.0, reason: item.heritageKind, + }); + } + } + return; + + case 'properties': { + const fileId = generateId('File', file.path); + const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path); + for (const item of routed.items) { + const nodeId = generateId('Property', `${file.path}:${item.propName}`); + graph.addNode({ + id: nodeId, + label: 'Property' as any, // TODO: add 'Property' to graph node label union + properties: { + name: item.propName, filePath: file.path, + startLine: item.startLine, endLine: item.endLine, + language, isExported: true, + description: item.accessorType, + }, + }); + symbolTable.add(file.path, item.propName, nodeId, 'Property'); + const relId = generateId('DEFINES', `${fileId}->${nodeId}`); + graph.addRelationship({ + id: relId, sourceId: fileId, targetId: nodeId, + type: 'DEFINES', confidence: 1.0, reason: '', + }); + if (propEnclosingClassId) { + graph.addRelationship({ + id: generateId('HAS_METHOD', `${propEnclosingClassId}->${nodeId}`), + sourceId: propEnclosingClassId, targetId: nodeId, + type: 'HAS_METHOD', confidence: 1.0, reason: '', + }); + } + } + return; + } + + case 'call': + break; // fall through to normal call processing below + } + } + // Skip common built-ins and noise if (isBuiltInOrNoise(calledName)) return; @@ -200,10 +321,10 @@ export const processCalls = async ( // 5. Find the enclosing function (caller) const callNode = captureMap['call']; const enclosingFuncId = findEnclosingFunction(callNode, file.path, symbolTable); - + // Use enclosing function as source, fallback to file for top-level calls const sourceId = enclosingFuncId || generateId('File', file.path); - + const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`); graph.addRelationship({ @@ -216,6 +337,58 @@ export const processCalls = async ( }); }); + // Extract Laravel routes from route files via procedural AST walk + if (language === 'php' && (file.path.includes('/routes/') || file.path.startsWith('routes/')) && file.path.endsWith('.php')) { + const extractedRoutes = extractLaravelRoutes(tree, file.path); + for (const route of extractedRoutes) { + if (!route.controllerName || !route.methodName) continue; + + const controllerDefs = symbolTable.lookupFuzzy(route.controllerName); + if (controllerDefs.length === 0) continue; + + const routeImportedFiles = importMap.get(route.filePath); + let controllerDef = controllerDefs[0]; + let conf = controllerDefs.length === 1 ? 0.7 : 0.5; + + if (routeImportedFiles) { + for (const def of controllerDefs) { + if (routeImportedFiles.has(def.filePath)) { + controllerDef = def; + conf = 0.9; + break; + } + } + } + + const methodId = symbolTable.lookupExact(controllerDef.filePath, route.methodName); + const routeSourceId = generateId('File', route.filePath); + + if (!methodId) { + const guessedId = generateId('Method', `${controllerDef.filePath}:${route.methodName}`); + const routeRelId = generateId('CALLS', `${routeSourceId}:route->${guessedId}`); + graph.addRelationship({ + id: routeRelId, + sourceId: routeSourceId, + targetId: guessedId, + type: 'CALLS', + confidence: conf * 0.8, + reason: 'laravel-route', + }); + continue; + } + + const routeRelId = generateId('CALLS', `${routeSourceId}:route->${methodId}`); + graph.addRelationship({ + id: routeRelId, + sourceId: routeSourceId, + targetId: methodId, + type: 'CALLS', + confidence: conf, + reason: 'laravel-route', + }); + } + } + // Cleanup if re-parsed if (wasReparsed) { tree.delete(); @@ -223,6 +396,387 @@ export const processCalls = async ( } }; +// ============================================================================ +// Laravel Route Extraction (procedural AST walk) +// ============================================================================ + +interface ExtractedRoute { + filePath: string; + httpMethod: string; + routePath: string | null; + controllerName: string | null; + methodName: string | null; + middleware: string[]; + prefix: string | null; + lineNumber: number; +} + +interface RouteGroupContext { + middleware: string[]; + prefix: string | null; + controller: string | null; +} + +const ROUTE_HTTP_METHODS = new Set([ + 'get', 'post', 'put', 'patch', 'delete', 'options', 'any', 'match', +]); + +const ROUTE_RESOURCE_METHODS = new Set(['resource', 'apiResource']); + +const RESOURCE_ACTIONS = ['index', 'create', 'store', 'show', 'edit', 'update', 'destroy']; +const API_RESOURCE_ACTIONS = ['index', 'store', 'show', 'update', 'destroy']; + +function isRouteStaticCall(node: any): boolean { + if (node.type !== 'scoped_call_expression') return false; + const obj = node.childForFieldName?.('object') ?? node.children?.[0]; + return obj?.text === 'Route'; +} + +function getCallMethodName(node: any): string | null { + const nameNode = node.childForFieldName?.('name') ?? + node.children?.find((c: any) => c.type === 'name'); + return nameNode?.text ?? null; +} + +function getArguments(node: any): any { + return node.children?.find((c: any) => c.type === 'arguments') ?? null; +} + +function findClosureBody(argsNode: any): any | null { + if (!argsNode) return null; + for (const child of argsNode.children ?? []) { + if (child.type === 'argument') { + for (const inner of child.children ?? []) { + if (inner.type === 'anonymous_function' || + inner.type === 'arrow_function') { + return inner.childForFieldName?.('body') ?? + inner.children?.find((c: any) => c.type === 'compound_statement'); + } + } + } + if (child.type === 'anonymous_function' || + child.type === 'arrow_function') { + return child.childForFieldName?.('body') ?? + child.children?.find((c: any) => c.type === 'compound_statement'); + } + } + return null; +} + +function findDescendant(node: any, type: string): any { + if (node.type === type) return node; + for (const child of (node.children ?? [])) { + const found = findDescendant(child, type); + if (found) return found; + } + return null; +} + +function extractStringContent(node: any): string | null { + if (!node) return null; + const content = node.children?.find((c: any) => c.type === 'string_content'); + if (content) return content.text; + if (node.type === 'string_content') return node.text; + return null; +} + +function extractFirstStringArg(argsNode: any): string | null { + if (!argsNode) return null; + for (const child of argsNode.children ?? []) { + const target = child.type === 'argument' ? child.children?.[0] : child; + if (!target) continue; + if (target.type === 'string' || target.type === 'encapsed_string') { + return extractStringContent(target); + } + } + return null; +} + +function extractMiddlewareArg(argsNode: any): string[] { + if (!argsNode) return []; + for (const child of argsNode.children ?? []) { + const target = child.type === 'argument' ? child.children?.[0] : child; + if (!target) continue; + if (target.type === 'string' || target.type === 'encapsed_string') { + const val = extractStringContent(target); + return val ? [val] : []; + } + if (target.type === 'array_creation_expression') { + const items: string[] = []; + for (const el of target.children ?? []) { + if (el.type === 'array_element_initializer') { + const str = el.children?.find((c: any) => c.type === 'string' || c.type === 'encapsed_string'); + const val = str ? extractStringContent(str) : null; + if (val) items.push(val); + } + } + return items; + } + } + return []; +} + +function extractClassArg(argsNode: any): string | null { + if (!argsNode) return null; + for (const child of argsNode.children ?? []) { + const target = child.type === 'argument' ? child.children?.[0] : child; + if (target?.type === 'class_constant_access_expression') { + return target.children?.find((c: any) => c.type === 'name')?.text ?? null; + } + } + return null; +} + +function extractControllerTarget(argsNode: any): { controller: string | null; method: string | null } { + if (!argsNode) return { controller: null, method: null }; + + const args: any[] = []; + for (const child of argsNode.children ?? []) { + if (child.type === 'argument') args.push(child.children?.[0]); + else if (child.type !== '(' && child.type !== ')' && child.type !== ',') args.push(child); + } + + const handlerNode = args[1]; + if (!handlerNode) return { controller: null, method: null }; + + if (handlerNode.type === 'array_creation_expression') { + let controller: string | null = null; + let method: string | null = null; + const elements: any[] = []; + for (const el of handlerNode.children ?? []) { + if (el.type === 'array_element_initializer') elements.push(el); + } + if (elements[0]) { + const classAccess = findDescendant(elements[0], 'class_constant_access_expression'); + if (classAccess) { + controller = classAccess.children?.find((c: any) => c.type === 'name')?.text ?? null; + } + } + if (elements[1]) { + const str = findDescendant(elements[1], 'string'); + method = str ? extractStringContent(str) : null; + } + return { controller, method }; + } + + if (handlerNode.type === 'string' || handlerNode.type === 'encapsed_string') { + const text = extractStringContent(handlerNode); + if (text?.includes('@')) { + const [controller, method] = text.split('@'); + return { controller, method }; + } + } + + if (handlerNode.type === 'class_constant_access_expression') { + const controller = handlerNode.children?.find((c: any) => c.type === 'name')?.text ?? null; + return { controller, method: '__invoke' }; + } + + return { controller: null, method: null }; +} + +interface ChainedRouteCall { + isRouteFacade: boolean; + terminalMethod: string; + attributes: { method: string; argsNode: any }[]; + terminalArgs: any; + node: any; +} + +function unwrapRouteChain(node: any): ChainedRouteCall | null { + if (node.type !== 'member_call_expression') return null; + + const terminalMethod = getCallMethodName(node); + if (!terminalMethod) return null; + + const terminalArgs = getArguments(node); + const attributes: { method: string; argsNode: any }[] = []; + + let current = node.children?.[0]; + + while (current) { + if (current.type === 'member_call_expression') { + const method = getCallMethodName(current); + const args = getArguments(current); + if (method) attributes.unshift({ method, argsNode: args }); + current = current.children?.[0]; + } else if (current.type === 'scoped_call_expression') { + const obj = current.childForFieldName?.('object') ?? current.children?.[0]; + if (obj?.text !== 'Route') return null; + + const method = getCallMethodName(current); + const args = getArguments(current); + if (method) attributes.unshift({ method, argsNode: args }); + + return { isRouteFacade: true, terminalMethod, attributes, terminalArgs, node }; + } else { + break; + } + } + + return null; +} + +function parseArrayGroupArgs(argsNode: any): RouteGroupContext { + const ctx: RouteGroupContext = { middleware: [], prefix: null, controller: null }; + if (!argsNode) return ctx; + + for (const child of argsNode.children ?? []) { + const target = child.type === 'argument' ? child.children?.[0] : child; + if (target?.type === 'array_creation_expression') { + for (const el of target.children ?? []) { + if (el.type !== 'array_element_initializer') continue; + const children = el.children ?? []; + const arrowIdx = children.findIndex((c: any) => c.type === '=>'); + if (arrowIdx === -1) continue; + const key = extractStringContent(children[arrowIdx - 1]); + const val = children[arrowIdx + 1]; + if (key === 'middleware') { + if (val?.type === 'string') { + const s = extractStringContent(val); + if (s) ctx.middleware.push(s); + } else if (val?.type === 'array_creation_expression') { + for (const item of val.children ?? []) { + if (item.type === 'array_element_initializer') { + const str = item.children?.find((c: any) => c.type === 'string'); + const s = str ? extractStringContent(str) : null; + if (s) ctx.middleware.push(s); + } + } + } + } else if (key === 'prefix') { + ctx.prefix = extractStringContent(val) ?? null; + } else if (key === 'controller') { + if (val?.type === 'class_constant_access_expression') { + ctx.controller = val.children?.find((c: any) => c.type === 'name')?.text ?? null; + } + } + } + } + } + return ctx; +} + +function extractLaravelRoutes(tree: any, filePath: string): ExtractedRoute[] { + const routes: ExtractedRoute[] = []; + + function resolveStack(stack: RouteGroupContext[]): { middleware: string[]; prefix: string | null; controller: string | null } { + const middleware: string[] = []; + let prefix: string | null = null; + let controller: string | null = null; + for (const ctx of stack) { + middleware.push(...ctx.middleware); + if (ctx.prefix) prefix = prefix ? `${prefix}/${ctx.prefix}`.replace(/\/+/g, '/') : ctx.prefix; + if (ctx.controller) controller = ctx.controller; + } + return { middleware, prefix, controller }; + } + + function emitRoute( + httpMethod: string, + argsNode: any, + lineNumber: number, + groupStack: RouteGroupContext[], + chainAttrs: { method: string; argsNode: any }[], + ) { + const effective = resolveStack(groupStack); + + for (const attr of chainAttrs) { + if (attr.method === 'middleware') effective.middleware.push(...extractMiddlewareArg(attr.argsNode)); + if (attr.method === 'prefix') { + const p = extractFirstStringArg(attr.argsNode); + if (p) effective.prefix = effective.prefix ? `${effective.prefix}/${p}` : p; + } + if (attr.method === 'controller') { + const cls = extractClassArg(attr.argsNode); + if (cls) effective.controller = cls; + } + } + + const routePath = extractFirstStringArg(argsNode); + + if (ROUTE_RESOURCE_METHODS.has(httpMethod)) { + const target = extractControllerTarget(argsNode); + const actions = httpMethod === 'apiResource' ? API_RESOURCE_ACTIONS : RESOURCE_ACTIONS; + for (const action of actions) { + routes.push({ + filePath, httpMethod, routePath, + controllerName: target.controller ?? effective.controller, + methodName: action, + middleware: [...effective.middleware], + prefix: effective.prefix, + lineNumber, + }); + } + } else { + const target = extractControllerTarget(argsNode); + routes.push({ + filePath, httpMethod, routePath, + controllerName: target.controller ?? effective.controller, + methodName: target.method, + middleware: [...effective.middleware], + prefix: effective.prefix, + lineNumber, + }); + } + } + + function walk(node: any, groupStack: RouteGroupContext[]) { + if (isRouteStaticCall(node)) { + const method = getCallMethodName(node); + if (method && (ROUTE_HTTP_METHODS.has(method) || ROUTE_RESOURCE_METHODS.has(method))) { + emitRoute(method, getArguments(node), node.startPosition.row, groupStack, []); + return; + } + if (method === 'group') { + const argsNode = getArguments(node); + const groupCtx = parseArrayGroupArgs(argsNode); + const body = findClosureBody(argsNode); + if (body) { + groupStack.push(groupCtx); + walkChildren(body, groupStack); + groupStack.pop(); + } + return; + } + } + + const chain = unwrapRouteChain(node); + if (chain) { + if (chain.terminalMethod === 'group') { + const groupCtx: RouteGroupContext = { middleware: [], prefix: null, controller: null }; + for (const attr of chain.attributes) { + if (attr.method === 'middleware') groupCtx.middleware.push(...extractMiddlewareArg(attr.argsNode)); + if (attr.method === 'prefix') groupCtx.prefix = extractFirstStringArg(attr.argsNode); + if (attr.method === 'controller') groupCtx.controller = extractClassArg(attr.argsNode); + } + const body = findClosureBody(chain.terminalArgs); + if (body) { + groupStack.push(groupCtx); + walkChildren(body, groupStack); + groupStack.pop(); + } + return; + } + if (ROUTE_HTTP_METHODS.has(chain.terminalMethod) || ROUTE_RESOURCE_METHODS.has(chain.terminalMethod)) { + emitRoute(chain.terminalMethod, chain.terminalArgs, node.startPosition.row, groupStack, chain.attributes); + return; + } + } + + walkChildren(node, groupStack); + } + + function walkChildren(node: any, groupStack: RouteGroupContext[]) { + for (const child of node.children ?? []) { + walk(child, groupStack); + } + } + + walk(tree.rootNode, []); + return routes; +} + /** * Resolution result with confidence scoring */ @@ -278,37 +832,72 @@ const resolveCallTarget = ( * Filter out common built-in functions and noise * that shouldn't be tracked as calls */ -const isBuiltInOrNoise = (name: string): boolean => { - const builtIns = new Set([ - // JavaScript/TypeScript built-ins - 'console', 'log', 'warn', 'error', 'info', 'debug', - 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', - 'parseInt', 'parseFloat', 'isNaN', 'isFinite', - 'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent', - 'JSON', 'parse', 'stringify', - 'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt', - 'Map', 'Set', 'WeakMap', 'WeakSet', - 'Promise', 'resolve', 'reject', 'then', 'catch', 'finally', - 'Math', 'Date', 'RegExp', 'Error', - 'require', 'import', 'export', - 'fetch', 'Response', 'Request', - // React hooks and common functions - 'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext', - 'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue', - 'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy', - // Common array/object methods - 'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every', - 'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split', - 'push', 'pop', 'shift', 'unshift', 'sort', 'reverse', - 'keys', 'values', 'entries', 'assign', 'freeze', 'seal', - 'hasOwnProperty', 'toString', 'valueOf', - // Python built-ins - 'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple', - 'open', 'read', 'write', 'close', 'append', 'extend', 'update', - 'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr', - 'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs', - ]); +/** Pre-built set (module-level singleton) to avoid re-creating per call */ +const BUILT_IN_NAMES = new Set([ + // JavaScript/TypeScript built-ins + 'console', 'log', 'warn', 'error', 'info', 'debug', + 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', + 'parseInt', 'parseFloat', 'isNaN', 'isFinite', + 'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent', + 'JSON', 'parse', 'stringify', + 'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt', + 'Map', 'Set', 'WeakMap', 'WeakSet', + 'Promise', 'resolve', 'reject', 'then', 'catch', 'finally', + 'Math', 'Date', 'RegExp', 'Error', + 'require', 'import', 'export', + 'fetch', 'Response', 'Request', + // React hooks and common functions + 'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext', + 'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue', + 'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy', + // Common array/object methods + 'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every', + 'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split', + 'push', 'pop', 'shift', 'unshift', 'sort', 'reverse', + 'keys', 'values', 'entries', 'assign', 'freeze', 'seal', + 'hasOwnProperty', 'toString', 'valueOf', + // Python built-ins + 'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple', + 'open', 'read', 'write', 'close', 'append', 'extend', 'update', + 'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr', + 'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs', + // C/C++ standard library and common kernel helpers + 'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf', + 'scanf', 'fscanf', 'sscanf', + 'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp', + 'strlen', 'strcpy', 'strncpy', 'strcat', 'strncat', 'strcmp', 'strncmp', 'strstr', 'strchr', 'strrchr', + 'atoi', 'atol', 'atof', 'strtol', 'strtoul', 'strtoll', 'strtoull', 'strtod', + 'sizeof', 'offsetof', 'typeof', + 'assert', 'abort', 'exit', '_exit', + 'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs', + // Linux kernel common macros/helpers (not real call targets) + 'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE', + 'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL', + 'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe', + 'min', 'max', 'clamp', 'abs', 'swap', + 'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg', + 'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg', + 'GFP_KERNEL', 'GFP_ATOMIC', + 'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore', + 'mutex_lock', 'mutex_unlock', 'mutex_init', + 'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree', + 'get', 'put', + // Ruby built-ins and Kernel methods + 'puts', 'print', 'p', 'pp', 'warn', 'raise', 'fail', + 'require', 'require_relative', 'load', 'autoload', + 'include', 'extend', 'prepend', + 'attr_accessor', 'attr_reader', 'attr_writer', + 'public', 'private', 'protected', 'module_function', + 'lambda', 'proc', 'block_given?', + 'nil?', 'is_a?', 'kind_of?', 'instance_of?', 'respond_to?', + 'freeze', 'frozen?', 'dup', 'clone', 'tap', 'then', 'yield_self', + // Ruby enumerables + 'each', 'map', 'select', 'reject', 'find', 'detect', 'collect', + 'inject', 'reduce', 'flat_map', 'each_with_object', 'each_with_index', + 'any?', 'all?', 'none?', 'count', 'first', 'last', + 'sort', 'sort_by', 'min', 'max', 'min_by', 'max_by', + 'group_by', 'partition', 'zip', 'compact', 'flatten', 'uniq', +]); - return builtIns.has(name); -}; +const isBuiltInOrNoise = (name: string): boolean => BUILT_IN_NAMES.has(name); diff --git a/gitnexus-web/src/core/ingestion/call-routing.ts b/gitnexus-web/src/core/ingestion/call-routing.ts new file mode 100644 index 0000000000..5a112aca15 --- /dev/null +++ b/gitnexus-web/src/core/ingestion/call-routing.ts @@ -0,0 +1,149 @@ +/** + * Shared Ruby call routing logic. + * + * Ruby expresses imports, heritage (mixins), and property definitions as + * method calls rather than syntax-level constructs. This module provides a + * routing function used by the CLI call-processor, CLI parse-worker, and + * the web call-processor so that the classification logic lives in one place. + * + * NOTE: This file is intentionally duplicated in gitnexus-web/ because the + * two packages have separate build targets (Node native vs WASM/browser). + * Keep both copies in sync until a shared package is introduced. + */ + +import { SupportedLanguages } from '../../config/supported-languages'; + +// ── Call routing dispatch table ───────────────────────────────────────────── + +/** null = this call was not routed; fall through to default call handling */ +export type CallRoutingResult = RubyCallRouting | null; + +export type CallRouter = ( + calledName: string, + callNode: any, +) => CallRoutingResult; + +/** No-op router: returns null for every call (passthrough to normal processing) */ +const noRouting: CallRouter = () => null; + +/** Per-language call routing. noRouting = no special routing (normal call processing) */ +export const callRouters = { + [SupportedLanguages.JavaScript]: noRouting, + [SupportedLanguages.TypeScript]: noRouting, + [SupportedLanguages.Python]: noRouting, + [SupportedLanguages.Java]: noRouting, + [SupportedLanguages.Go]: noRouting, + [SupportedLanguages.Rust]: noRouting, + [SupportedLanguages.CSharp]: noRouting, + [SupportedLanguages.PHP]: noRouting, + [SupportedLanguages.Swift]: noRouting, + [SupportedLanguages.CPlusPlus]: noRouting, + [SupportedLanguages.C]: noRouting, + [SupportedLanguages.Ruby]: routeRubyCall, + [SupportedLanguages.Kotlin]: noRouting, +} satisfies Record<SupportedLanguages, CallRouter>; + +// ── Result types ──────────────────────────────────────────────────────────── + +export type RubyCallRouting = + | { kind: 'import'; importPath: string; isRelative: boolean } + | { kind: 'heritage'; items: RubyHeritageItem[] } + | { kind: 'properties'; items: RubyPropertyItem[] } + | { kind: 'call' } + | { kind: 'skip' }; + +export interface RubyHeritageItem { + enclosingClass: string; + mixinName: string; + heritageKind: 'include' | 'extend' | 'prepend'; +} + +export type RubyAccessorType = 'attr_accessor' | 'attr_reader' | 'attr_writer'; + +export interface RubyPropertyItem { + propName: string; + accessorType: RubyAccessorType; + startLine: number; + endLine: number; +} + +// ── Pre-allocated singletons for common return values ──────────────────────── +const CALL_RESULT: RubyCallRouting = { kind: 'call' }; +const SKIP_RESULT: RubyCallRouting = { kind: 'skip' }; + +/** Max depth for parent-walking loops to prevent pathological AST traversals */ +const MAX_PARENT_DEPTH = 50; + +// ── Routing function ──────────────────────────────────────────────────────── + +/** + * Classify a Ruby call node and extract its semantic payload. + * + * @param calledName - The method name (e.g. 'require', 'include', 'attr_accessor') + * @param callNode - The tree-sitter `call` AST node + * @returns A discriminated union describing the call's semantic role + */ +export function routeRubyCall(calledName: string, callNode: any): RubyCallRouting { + // ── require / require_relative → import ───────────────────────────────── + if (calledName === 'require' || calledName === 'require_relative') { + const argList = callNode.childForFieldName?.('arguments'); + const stringNode = argList?.children?.find((c: any) => c.type === 'string'); + const contentNode = stringNode?.children?.find((c: any) => c.type === 'string_content'); + if (!contentNode) return SKIP_RESULT; + + let importPath: string = contentNode.text; + // Validate: reject null bytes, control chars, excessively long paths + if (!importPath || importPath.length > 1024 || /[\x00-\x1f]/.test(importPath)) { + return SKIP_RESULT; + } + const isRelative = calledName === 'require_relative'; + if (isRelative && !importPath.startsWith('.')) { + importPath = './' + importPath; + } + return { kind: 'import', importPath, isRelative }; + } + + // ── include / extend / prepend → heritage (mixin) ────────────────────── + if (calledName === 'include' || calledName === 'extend' || calledName === 'prepend') { + let enclosingClass: string | null = null; + let current = callNode.parent; + let depth = 0; + while (current && ++depth <= MAX_PARENT_DEPTH) { + if (current.type === 'class' || current.type === 'module') { + const nameNode = current.childForFieldName?.('name'); + if (nameNode) { enclosingClass = nameNode.text; break; } + } + current = current.parent; + } + if (!enclosingClass) return SKIP_RESULT; + + const items: RubyHeritageItem[] = []; + const argList = callNode.childForFieldName?.('arguments'); + for (const arg of (argList?.children ?? [])) { + if (arg.type === 'constant' || arg.type === 'scope_resolution') { + items.push({ enclosingClass, mixinName: arg.text, heritageKind: calledName as 'include' | 'extend' | 'prepend' }); + } + } + return items.length > 0 ? { kind: 'heritage', items } : SKIP_RESULT; + } + + // ── attr_accessor / attr_reader / attr_writer → property definitions ─── + if (calledName === 'attr_accessor' || calledName === 'attr_reader' || calledName === 'attr_writer') { + const items: RubyPropertyItem[] = []; + const argList = callNode.childForFieldName?.('arguments'); + for (const arg of (argList?.children ?? [])) { + if (arg.type === 'simple_symbol') { + items.push({ + propName: arg.text.startsWith(':') ? arg.text.slice(1) : arg.text, + accessorType: calledName as RubyAccessorType, + startLine: arg.startPosition.row, + endLine: arg.endPosition.row, + }); + } + } + return items.length > 0 ? { kind: 'properties', items } : SKIP_RESULT; + } + + // ── Everything else → regular call ───────────────────────────────────── + return CALL_RESULT; +} diff --git a/gitnexus-web/src/core/ingestion/community-processor.ts b/gitnexus-web/src/core/ingestion/community-processor.ts index 5d898f1ba3..d4a0ccbc70 100644 --- a/gitnexus-web/src/core/ingestion/community-processor.ts +++ b/gitnexus-web/src/core/ingestion/community-processor.ts @@ -330,25 +330,20 @@ const calculateCohesion = (memberIds: string[], graph: Graph): number => { const memberSet = new Set(memberIds); let internalEdges = 0; - - // Count edges within the community + let totalEdges = 0; + + // Count internal vs total edges for community members memberIds.forEach(nodeId => { if (graph.hasNode(nodeId)) { graph.forEachNeighbor(nodeId, neighbor => { + totalEdges++; if (memberSet.has(neighbor)) { internalEdges++; } }); } }); - - // Each edge is counted twice (once from each end), so divide by 2 - internalEdges = internalEdges / 2; - - // Maximum possible internal edges for n nodes: n*(n-1)/2 - const maxPossibleEdges = (memberIds.length * (memberIds.length - 1)) / 2; - - if (maxPossibleEdges === 0) return 1.0; - - return Math.min(1.0, internalEdges / maxPossibleEdges); + + if (totalEdges === 0) return 1.0; + return Math.min(1.0, internalEdges / totalEdges); }; diff --git a/gitnexus-web/src/core/ingestion/entry-point-scoring.ts b/gitnexus-web/src/core/ingestion/entry-point-scoring.ts index 1ef3d3ddc6..f53ce06d60 100644 --- a/gitnexus-web/src/core/ingestion/entry-point-scoring.ts +++ b/gitnexus-web/src/core/ingestion/entry-point-scoring.ts @@ -13,7 +13,7 @@ import { detectFrameworkFromPath } from './framework-detection'; // ============================================================================ -// NAME PATTERNS - All 9 supported languages +// NAME PATTERNS - All 11 supported languages // ============================================================================ /** @@ -102,6 +102,54 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = { /^Run$/, // Run methods /^Start$/, // Start methods ], + + // Swift / iOS + 'swift': [ + /^viewDidLoad$/, // UIKit lifecycle + /^viewWillAppear$/, // UIKit lifecycle + /^viewDidAppear$/, // UIKit lifecycle + /^viewWillDisappear$/, // UIKit lifecycle + /^viewDidDisappear$/, // UIKit lifecycle + /^application\(/, // AppDelegate methods + /^scene\(/, // SceneDelegate methods + /^body$/, // SwiftUI View.body + /Coordinator$/, // Coordinator pattern + /^sceneDidBecomeActive$/, // SceneDelegate lifecycle + /^sceneWillResignActive$/, // SceneDelegate lifecycle + /^didFinishLaunchingWithOptions$/, // AppDelegate + /ViewController$/, // ViewController classes + /^configure[A-Z]/, // Configuration methods + /^setup[A-Z]/, // Setup methods + /^makeBody$/, // SwiftUI ViewModifier + ], + + // PHP / Laravel + 'php': [ + /Controller$/, // UserController (class name convention) + /^handle$/, // Job::handle(), Listener::handle() + /^execute$/, // Command::execute() + /^boot$/, // ServiceProvider::boot() + /^register$/, // ServiceProvider::register() + /^__invoke$/, // Invokable controllers/actions + /^(index|show|store|update|destroy|create|edit)$/, // RESTful resource methods + /^(get|post|put|delete|patch)[A-Z]/, // Explicit HTTP method actions + /^run$/, // Command/Job run() + /^fire$/, // Event fire() + /^dispatch$/, // Dispatchable jobs + /Service$/, // UserService (Service layer) + /Repository$/, // UserRepository (Repository pattern) + /^find$/, // Repository::find() + /^findAll$/, // Repository::findAll() + /^save$/, // Repository::save() + /^delete$/, // Repository::delete() + ], + + // Ruby + 'ruby': [ + /^call$/, // Service objects (MyService.call) + /^perform$/, // Background jobs (Sidekiq, ActiveJob) + /^execute$/, // Command pattern + ], }; // ============================================================================ @@ -250,9 +298,23 @@ export function isTestFile(filePath: string): boolean { p.includes('/src/test/') || // Rust test patterns (inline tests are different, but test files) p.includes('/tests/') || + // Swift/iOS test patterns + p.endsWith('tests.swift') || + p.endsWith('test.swift') || + p.includes('uitests/') || // C# test patterns p.includes('.tests/') || - p.includes('tests.cs') + p.includes('tests.cs') || + // PHP/Laravel test patterns + p.endsWith('test.php') || + p.endsWith('spec.php') || + p.includes('/tests/feature/') || + p.includes('/tests/unit/') || + // Ruby test patterns + p.endsWith('_spec.rb') || + p.endsWith('_test.rb') || + p.includes('/spec/') || + p.includes('/test/fixtures/') ); } diff --git a/gitnexus-web/src/core/ingestion/framework-detection.ts b/gitnexus-web/src/core/ingestion/framework-detection.ts index d3c75ab876..b190e4baf5 100644 --- a/gitnexus-web/src/core/ingestion/framework-detection.ts +++ b/gitnexus-web/src/core/ingestion/framework-detection.ts @@ -195,22 +195,143 @@ export function detectFrameworkFromPath(filePath: string): FrameworkHint | null return { framework: 'c-cpp', entryPointMultiplier: 2.5, reason: 'c-app' }; } + // ========== PHP / LARAVEL FRAMEWORKS ========== + + // Laravel routes (highest - these ARE the entry point definitions) + if (p.includes('/routes/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-routes' }; + } + + // Laravel controllers (very high - receive HTTP requests) + if ((p.includes('/http/controllers/') || p.includes('/controllers/')) && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller' }; + } + + // Laravel controller by file name convention + if (p.endsWith('controller.php')) { + return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller-file' }; + } + + // Laravel console commands + if ((p.includes('/console/commands/') || p.includes('/commands/')) && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-command' }; + } + + // Laravel jobs (queue entry points) + if (p.includes('/jobs/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-job' }; + } + + // Laravel listeners (event-driven entry points) + if (p.includes('/listeners/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-listener' }; + } + + // Laravel middleware + if (p.includes('/http/middleware/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-middleware' }; + } + + // Laravel service providers + if (p.includes('/providers/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-provider' }; + } + + // Laravel policies + if (p.includes('/policies/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.0, reason: 'laravel-policy' }; + } + + // Laravel models (important but not entry points per se) + if (p.includes('/models/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-model' }; + } + + // Laravel services (Service Repository pattern) + if (p.includes('/services/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-service' }; + } + + // Laravel repositories (Service Repository pattern) + if (p.includes('/repositories/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-repository' }; + } + + // ========== RUBY ========== + + // Ruby: bin/ or exe/ (CLI entry points) + if ((p.includes('/bin/') || p.includes('/exe/')) && p.endsWith('.rb')) { + return { framework: 'ruby', entryPointMultiplier: 2.5, reason: 'ruby-executable' }; + } + + // Ruby: Rakefile or *.rake (task definitions) + if (p.endsWith('/rakefile') || p.endsWith('.rake')) { + return { framework: 'ruby', entryPointMultiplier: 1.5, reason: 'ruby-rake' }; + } + // ========== SWIFT / iOS ========== + + // iOS App entry points (highest priority) + if (p.endsWith('/appdelegate.swift') || p.endsWith('/scenedelegate.swift') || p.endsWith('/app.swift')) { + return { framework: 'ios', entryPointMultiplier: 3.0, reason: 'ios-app-entry' }; + } + + // SwiftUI App entry (@main) + if (p.endsWith('app.swift') && p.includes('/sources/')) { + return { framework: 'swiftui', entryPointMultiplier: 3.0, reason: 'swiftui-app' }; + } + + // UIKit ViewControllers (high priority - screen entry points) + if ((p.includes('/viewcontrollers/') || p.includes('/controllers/') || p.includes('/screens/')) && p.endsWith('.swift')) { + return { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-viewcontroller' }; + } + + // ViewController by filename convention + if (p.endsWith('viewcontroller.swift') || p.endsWith('vc.swift')) { + return { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-viewcontroller-file' }; + } + + // Coordinator pattern (navigation entry points) + if (p.includes('/coordinators/') && p.endsWith('.swift')) { + return { framework: 'ios-coordinator', entryPointMultiplier: 2.5, reason: 'ios-coordinator' }; + } + + // Coordinator by filename + if (p.endsWith('coordinator.swift')) { + return { framework: 'ios-coordinator', entryPointMultiplier: 2.5, reason: 'ios-coordinator-file' }; + } + + // SwiftUI Views (moderate - reusable components) + if ((p.includes('/views/') || p.includes('/scenes/')) && p.endsWith('.swift')) { + return { framework: 'swiftui', entryPointMultiplier: 1.8, reason: 'swiftui-view' }; + } + + // Service layer + if (p.includes('/services/') && p.endsWith('.swift')) { + return { framework: 'ios-service', entryPointMultiplier: 1.8, reason: 'ios-service' }; + } + + // Router / navigation + if (p.includes('/router/') && p.endsWith('.swift')) { + return { framework: 'ios-router', entryPointMultiplier: 2.0, reason: 'ios-router' }; + } + // ========== GENERIC PATTERNS ========== - + // Any language: index files in API folders if (p.includes('/api/') && ( - p.endsWith('/index.ts') || p.endsWith('/index.js') || + p.endsWith('/index.ts') || p.endsWith('/index.js') || p.endsWith('/__init__.py') )) { return { framework: 'api', entryPointMultiplier: 1.8, reason: 'api-index' }; } - + // No framework detected - return null for graceful fallback (1.0 multiplier) return null; } // ============================================================================ -// FUTURE: AST-BASED PATTERNS (for Phase 3) +// PARTIALLY IMPLEMENTED: Route::* detection via procedural AST walk in parse-worker/call-processor +// Remaining: NestJS, Express, FastAPI, Flask, Spring, etc. // ============================================================================ /** @@ -235,9 +356,18 @@ export const FRAMEWORK_AST_PATTERNS = { // Go patterns (function signatures) 'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP'], - + + // PHP/Laravel + 'laravel': ['Route::get', 'Route::post', 'Route::put', 'Route::delete', + 'Route::resource', 'Route::apiResource', '#[Route('], + // Rust macros 'actix': ['#[get', '#[post', '#[put', '#[delete'], 'axum': ['Router::new'], 'rocket': ['#[get', '#[post'], + + // Swift/iOS + 'uikit': ['viewDidLoad', 'viewWillAppear', 'viewDidAppear', 'UIViewController'], + 'swiftui': ['@main', 'WindowGroup', 'ContentView', '@StateObject', '@ObservedObject'], + 'combine': ['sink', 'assign', 'Publisher', 'Subscriber'], }; diff --git a/gitnexus-web/src/core/ingestion/import-processor.ts b/gitnexus-web/src/core/ingestion/import-processor.ts index c0cb6bd681..61aeaf9dd2 100644 --- a/gitnexus-web/src/core/ingestion/import-processor.ts +++ b/gitnexus-web/src/core/ingestion/import-processor.ts @@ -4,6 +4,7 @@ import { loadParser, loadLanguage } from '../tree-sitter/parser-loader'; import { LANGUAGE_QUERIES } from './tree-sitter-queries'; import { generateId } from '../../lib/utils'; import { getLanguageFromFilename } from './utils'; +import { callRouters } from './call-routing'; // Type: Map<FilePath, Set<ResolvedFilePath>> // Stores all files that a given file imports from @@ -53,7 +54,9 @@ const resolveImportPath = ( // Go '.go', // Rust - '.rs', '/mod.rs' + '.rs', '/mod.rs', + // Ruby + '.rb', '.rake', ]; if (importPath.startsWith('.')) { @@ -220,6 +223,35 @@ export const processImports = async ( importMap.get(file.path)!.add(resolvedPath); } } + + // ---- Language-specific call-as-import routing (Ruby require, etc.) ---- + if (captureMap['call']) { + const callNameNode = captureMap['call.name']; + if (callNameNode) { + const callRouter = callRouters[language]; + const routed = callRouter(callNameNode.text, captureMap['call']); + if (routed && routed.kind === 'import') { + totalImportsFound++; + const resolvedPath = resolveImportPath( + file.path, routed.importPath, allFilePaths, allFileList, resolveCache + ); + if (resolvedPath) { + const sourceId = generateId('File', file.path); + const targetId = generateId('File', resolvedPath); + const relId = generateId('IMPORTS', `${file.path}->${resolvedPath}`); + totalImportsResolved++; + graph.addRelationship({ + id: relId, sourceId, targetId, + type: 'IMPORTS', confidence: 1.0, reason: '', + }); + if (!importMap.has(file.path)) { + importMap.set(file.path, new Set()); + } + importMap.get(file.path)!.add(resolvedPath); + } + } + } + } }); // If re-parsed just for this, delete the tree to save memory diff --git a/gitnexus-web/src/core/ingestion/parsing-processor.ts b/gitnexus-web/src/core/ingestion/parsing-processor.ts index 807bcf5815..a063db6ccd 100644 --- a/gitnexus-web/src/core/ingestion/parsing-processor.ts +++ b/gitnexus-web/src/core/ingestion/parsing-processor.ts @@ -14,7 +14,7 @@ export type FileProgressCallback = (current: number, total: number, filePath: st /** * Check if a symbol (function, class, etc.) is exported/public - * Handles all 9 supported languages with explicit logic + * Handles all 11 supported languages with explicit logic * * @param node - The AST node for the symbol name * @param name - The symbol name @@ -104,7 +104,11 @@ const isNodeExported = (node: any, name: string, language: string): boolean => { case 'c': case 'cpp': return false; - + + // Ruby: All top-level definitions are public by default + case 'ruby': + return true; + default: return false; } diff --git a/gitnexus-web/src/core/ingestion/tree-sitter-queries.ts b/gitnexus-web/src/core/ingestion/tree-sitter-queries.ts index a931b4a400..65b67bcafd 100644 --- a/gitnexus-web/src/core/ingestion/tree-sitter-queries.ts +++ b/gitnexus-web/src/core/ingestion/tree-sitter-queries.ts @@ -317,6 +317,172 @@ export const RUST_QUERIES = ` (impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (type_identifier) @heritage.class) @heritage `; +// PHP queries - works with tree-sitter-php (php_only grammar) +export const PHP_QUERIES = ` +; ── Namespace ──────────────────────────────────────────────────────────────── +(namespace_definition + name: (namespace_name) @name) @definition.namespace + +; ── Classes ────────────────────────────────────────────────────────────────── +(class_declaration + name: (name) @name) @definition.class + +; ── Interfaces ─────────────────────────────────────────────────────────────── +(interface_declaration + name: (name) @name) @definition.interface + +; ── Traits ─────────────────────────────────────────────────────────────────── +(trait_declaration + name: (name) @name) @definition.trait + +; ── Enums (PHP 8.1) ────────────────────────────────────────────────────────── +(enum_declaration + name: (name) @name) @definition.enum + +; ── Top-level functions ─────────────────────────────────────────────────────── +(function_definition + name: (name) @name) @definition.function + +; ── Methods (including constructors) ───────────────────────────────────────── +(method_declaration + name: (name) @name) @definition.method + +; ── Class properties (including Eloquent $fillable, $casts, etc.) ──────────── +(property_declaration + (property_element + (variable_name + (name) @name))) @definition.property + +; ── Imports: use statements ────────────────────────────────────────────────── +; Simple: use App\\Models\\User; +(namespace_use_declaration + (namespace_use_clause + (qualified_name) @import.source)) @import + +; ── Function/method calls ──────────────────────────────────────────────────── +; Regular function call: foo() +(function_call_expression + function: (name) @call.name) @call + +; Method call: $obj->method() +(member_call_expression + name: (name) @call.name) @call + +; Nullsafe method call: $obj?->method() +(nullsafe_member_call_expression + name: (name) @call.name) @call + +; Static call: Foo::bar() (php_only uses scoped_call_expression) +(scoped_call_expression + name: (name) @call.name) @call + +; ── Heritage: extends ──────────────────────────────────────────────────────── +(class_declaration + name: (name) @heritage.class + (base_clause + [(name) (qualified_name)] @heritage.extends)) @heritage + +; ── Heritage: implements ───────────────────────────────────────────────────── +(class_declaration + name: (name) @heritage.class + (class_interface_clause + [(name) (qualified_name)] @heritage.implements)) @heritage.impl + +; ── Heritage: use trait (must capture enclosing class name) ────────────────── +(class_declaration + name: (name) @heritage.class + body: (declaration_list + (use_declaration + [(name) (qualified_name)] @heritage.trait))) @heritage +`; + +// Ruby queries - works with tree-sitter-ruby +// NOTE: Ruby uses `call` for require, include, extend, prepend, attr_* etc. +// These are all captured as @call and routed in JS post-processing: +// - require/require_relative → import extraction +// - include/extend/prepend → heritage (mixin) extraction +// - attr_accessor/attr_reader/attr_writer → property definition extraction +// - everything else → regular call extraction +export const RUBY_QUERIES = ` +; ── Modules ────────────────────────────────────────────────────────────────── +(module + name: (constant) @name) @definition.module + +; ── Classes ────────────────────────────────────────────────────────────────── +(class + name: (constant) @name) @definition.class + +; ── Instance methods ───────────────────────────────────────────────────────── +(method + name: (identifier) @name) @definition.method + +; ── Singleton (class-level) methods ────────────────────────────────────────── +(singleton_method + name: (identifier) @name) @definition.function + +; ── All calls (require, include, attr_*, and regular calls routed in JS) ───── +(call + method: (identifier) @call.name) @call + +; ── Heritage: class < SuperClass ───────────────────────────────────────────── +(class + name: (constant) @heritage.class + superclass: (superclass + (constant) @heritage.extends)) @heritage`; + +// Swift queries - works with tree-sitter-swift +export const SWIFT_QUERIES = ` +; Classes +(class_declaration "class" name: (type_identifier) @name) @definition.class + +; Structs +(class_declaration "struct" name: (type_identifier) @name) @definition.struct + +; Enums +(class_declaration "enum" name: (type_identifier) @name) @definition.enum + +; Extensions (mapped to class — no dedicated label in schema) +(class_declaration "extension" name: (user_type (type_identifier) @name)) @definition.class + +; Actors +(class_declaration "actor" name: (type_identifier) @name) @definition.class + +; Protocols (mapped to interface) +(protocol_declaration name: (type_identifier) @name) @definition.interface + +; Type aliases +(typealias_declaration name: (type_identifier) @name) @definition.type + +; Functions (top-level and methods) +(function_declaration name: (simple_identifier) @name) @definition.function + +; Protocol method declarations +(protocol_function_declaration name: (simple_identifier) @name) @definition.method + +; Initializers +(init_declaration) @definition.constructor + +; Properties (stored and computed) +(property_declaration (pattern (simple_identifier) @name)) @definition.property + +; Imports +(import_declaration (identifier (simple_identifier) @import.source)) @import + +; Calls - direct function calls +(call_expression (simple_identifier) @call.name) @call + +; Calls - member/navigation calls (obj.method()) +(call_expression (navigation_expression (navigation_suffix (simple_identifier) @call.name))) @call + +; Heritage - class/struct/enum inheritance and protocol conformance +(class_declaration name: (type_identifier) @heritage.class + (inheritance_specifier inherits_from: (user_type (type_identifier) @heritage.extends))) @heritage + +; Heritage - protocol inheritance +(protocol_declaration name: (type_identifier) @heritage.class + (inheritance_specifier inherits_from: (user_type (type_identifier) @heritage.extends))) @heritage +`; + export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = { [SupportedLanguages.TypeScript]: TYPESCRIPT_QUERIES, [SupportedLanguages.JavaScript]: JAVASCRIPT_QUERIES, @@ -327,5 +493,9 @@ export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = { [SupportedLanguages.CPlusPlus]: CPP_QUERIES, [SupportedLanguages.CSharp]: CSHARP_QUERIES, [SupportedLanguages.Rust]: RUST_QUERIES, + [SupportedLanguages.PHP]: PHP_QUERIES, + [SupportedLanguages.Ruby]: RUBY_QUERIES, + [SupportedLanguages.Kotlin]: '', // Kotlin WASM parser not yet available for web + [SupportedLanguages.Swift]: SWIFT_QUERIES, }; \ No newline at end of file diff --git a/gitnexus-web/src/core/ingestion/utils.ts b/gitnexus-web/src/core/ingestion/utils.ts index 959eb55dca..22bb6d72e1 100644 --- a/gitnexus-web/src/core/ingestion/utils.ts +++ b/gitnexus-web/src/core/ingestion/utils.ts @@ -1,5 +1,8 @@ import { SupportedLanguages } from '../../config/supported-languages'; +/** Ruby extensionless filenames recognised as Ruby source */ +const RUBY_EXTENSIONLESS_FILES = new Set(['Rakefile', 'Gemfile', 'Guardfile', 'Vagrantfile', 'Brewfile']); + /** * Map file extension to SupportedLanguage enum */ @@ -25,6 +28,23 @@ export const getLanguageFromFilename = (filename: string): SupportedLanguages | if (filename.endsWith('.go')) return SupportedLanguages.Go; // Rust if (filename.endsWith('.rs')) return SupportedLanguages.Rust; + // PHP (all common extensions) + if (filename.endsWith('.php') || filename.endsWith('.phtml') || + filename.endsWith('.php3') || filename.endsWith('.php4') || + filename.endsWith('.php5') || filename.endsWith('.php8')) { + return SupportedLanguages.PHP; + } + // Ruby (extensions) + if (filename.endsWith('.rb') || filename.endsWith('.rake') || filename.endsWith('.gemspec')) { + return SupportedLanguages.Ruby; + } + // Ruby (extensionless files) + const basename = filename.split('/').pop() || filename; + if (RUBY_EXTENSIONLESS_FILES.has(basename)) { + return SupportedLanguages.Ruby; + } + // Swift + if (filename.endsWith('.swift')) return SupportedLanguages.Swift; return null; }; diff --git a/gitnexus-web/src/core/kuzu/csv-generator.ts b/gitnexus-web/src/core/lbug/csv-generator.ts similarity index 97% rename from gitnexus-web/src/core/kuzu/csv-generator.ts rename to gitnexus-web/src/core/lbug/csv-generator.ts index e565399cd5..aa85196ceb 100644 --- a/gitnexus-web/src/core/kuzu/csv-generator.ts +++ b/gitnexus-web/src/core/lbug/csv-generator.ts @@ -1,5 +1,5 @@ /** - * CSV Generator for KuzuDB Hybrid Schema + * CSV Generator for LadybugDB Hybrid Schema * * Generates separate CSV files for each node table and one relation CSV. * This enables efficient bulk loading via COPY FROM for hybrid schema. @@ -18,10 +18,10 @@ import { NODE_TABLES, NodeTableName } from './schema'; // ============================================================================ /** - * Sanitize string to ensure valid UTF-8 and safe CSV content for KuzuDB + * Sanitize string to ensure valid UTF-8 and safe CSV content for LadybugDB * Removes or replaces invalid characters that would break CSV parsing. * - * Critical: KuzuDB's CSV parser can misinterpret \r\n inside quoted fields. + * Critical: LadybugDB's CSV parser can misinterpret \r\n inside quoted fields. * We normalize all line endings to \n only. */ const sanitizeUTF8 = (str: string): string => { @@ -213,7 +213,7 @@ const generateCommunityCSV = (nodes: GraphNode[]): string => { for (const node of nodes) { if (node.label !== 'Community') continue; - // Handle keywords array - convert to KuzuDB array format + // Handle keywords array - convert to LadybugDB array format const keywords = (node.properties as any).keywords || []; const keywordsStr = `[${keywords.map((k: string) => `'${k.replace(/'/g, "''")}'`).join(',')}]`; @@ -221,7 +221,7 @@ const generateCommunityCSV = (nodes: GraphNode[]): string => { escapeCSVField(node.id), escapeCSVField(node.properties.name || ''), // label is stored in name escapeCSVField(node.properties.heuristicLabel || ''), - keywordsStr, // Array format for KuzuDB + keywordsStr, // Array format for LadybugDB escapeCSVField((node.properties as any).description || ''), escapeCSVField((node.properties as any).enrichedBy || 'heuristic'), escapeCSVNumber(node.properties.cohesion, 0), diff --git a/gitnexus-web/src/core/kuzu/kuzu-adapter.ts b/gitnexus-web/src/core/lbug/lbug-adapter.ts similarity index 79% rename from gitnexus-web/src/core/kuzu/kuzu-adapter.ts rename to gitnexus-web/src/core/lbug/lbug-adapter.ts index 52885b281a..eed042ce25 100644 --- a/gitnexus-web/src/core/kuzu/kuzu-adapter.ts +++ b/gitnexus-web/src/core/lbug/lbug-adapter.ts @@ -1,51 +1,51 @@ /** - * KuzuDB Adapter - * - * Manages the KuzuDB WASM instance for client-side graph database operations. + * LadybugDB Adapter + * + * Manages the LadybugDB WASM instance for client-side graph database operations. * Uses the "Snapshot / Bulk Load" pattern with COPY FROM for performance. - * + * * Multi-table schema: separate tables for File, Function, Class, etc. */ import { KnowledgeGraph } from '../graph/types'; -import { - NODE_TABLES, +import { + NODE_TABLES, REL_TABLE_NAME, - SCHEMA_QUERIES, + SCHEMA_QUERIES, EMBEDDING_TABLE_NAME, NodeTableName, } from './schema'; import { generateAllCSVs } from './csv-generator'; // Holds the reference to the dynamically loaded module -let kuzu: any = null; +let lbug: any = null; let db: any = null; let conn: any = null; /** - * Initialize KuzuDB WASM module and create in-memory database + * Initialize LadybugDB WASM module and create in-memory database */ -export const initKuzu = async () => { - if (conn) return { db, conn, kuzu }; +export const initLbug = async () => { + if (conn) return { db, conn, lbug }; try { - if (import.meta.env.DEV) console.log('🚀 Initializing KuzuDB...'); + if (import.meta.env.DEV) console.log('🚀 Initializing LadybugDB...'); // 1. Dynamic Import (Fixes the "not a function" bundler issue) - const kuzuModule = await import('kuzu-wasm'); - + const lbugModule = await import('@ladybugdb/wasm-core'); + // 2. Handle Vite/Webpack "default" wrapping - kuzu = kuzuModule.default || kuzuModule; + lbug = lbugModule.default || lbugModule; // 3. Initialize WASM - await kuzu.init(); - - // 4. Create Database with 512MB buffer pool + await lbug.init(); + + // 4. Create Database with 512MB buffer manager const BUFFER_POOL_SIZE = 512 * 1024 * 1024; // 512MB - db = new kuzu.Database(':memory:', BUFFER_POOL_SIZE); - conn = new kuzu.Connection(db); - - if (import.meta.env.DEV) console.log('✅ KuzuDB WASM Initialized'); + db = new lbug.Database(':memory:', BUFFER_POOL_SIZE); + conn = new lbug.Connection(db); + + if (import.meta.env.DEV) console.log('✅ LadybugDB WASM Initialized'); // 5. Initialize Schema (all node tables, then rel tables, then embedding table) for (const schemaQuery of SCHEMA_QUERIES) { @@ -58,60 +58,60 @@ export const initKuzu = async () => { } } } - - if (import.meta.env.DEV) console.log('✅ KuzuDB Multi-Table Schema Created'); - return { db, conn, kuzu }; + if (import.meta.env.DEV) console.log('✅ LadybugDB Multi-Table Schema Created'); + + return { db, conn, lbug }; } catch (error) { - if (import.meta.env.DEV) console.error('❌ KuzuDB Initialization Failed:', error); + if (import.meta.env.DEV) console.error('❌ LadybugDB Initialization Failed:', error); throw error; } }; /** - * Load a KnowledgeGraph into KuzuDB using COPY FROM (bulk load) + * Load a KnowledgeGraph into LadybugDB using COPY FROM (bulk load) * Uses batched CSV writes and COPY statements for optimal performance */ -export const loadGraphToKuzu = async ( - graph: KnowledgeGraph, +export const loadGraphToLbug = async ( + graph: KnowledgeGraph, fileContents: Map<string, string> ) => { - const { conn, kuzu } = await initKuzu(); - + const { conn, lbug } = await initLbug(); + try { - if (import.meta.env.DEV) console.log(`KuzuDB: Generating CSVs for ${graph.nodeCount} nodes...`); - + if (import.meta.env.DEV) console.log(`LadybugDB: Generating CSVs for ${graph.nodeCount} nodes...`); + // 1. Generate all CSVs (per-table) const csvData = generateAllCSVs(graph, fileContents); - - const fs = kuzu.FS; - + + const fs = lbug.FS; + // 2. Write all node CSVs to virtual filesystem const nodeFiles: Array<{ table: NodeTableName; path: string }> = []; for (const [tableName, csv] of csvData.nodes.entries()) { // Skip empty CSVs (only header row) if (csv.split('\n').length <= 1) continue; - + const path = `/${tableName.toLowerCase()}.csv`; try { await fs.unlink(path); } catch {} await fs.writeFile(path, csv); nodeFiles.push({ table: tableName, path }); } - + // 3. Parse relation CSV and prepare for INSERT (COPY FROM doesn't work with multi-pair tables) const relLines = csvData.relCSV.split('\n').slice(1).filter(line => line.trim()); const relCount = relLines.length; - + if (import.meta.env.DEV) { - console.log(`KuzuDB: Wrote ${nodeFiles.length} node CSVs, ${relCount} relations to insert`); + console.log(`LadybugDB: Wrote ${nodeFiles.length} node CSVs, ${relCount} relations to insert`); } - + // 4. COPY all node tables (must complete before rels due to FK constraints) for (const { table, path } of nodeFiles) { const copyQuery = getCopyQuery(table, path); await conn.query(copyQuery); } - + // 5. INSERT relations one by one (COPY doesn't work with multi-pair REL tables) // Build a set of valid table names for fast lookup const validTables = new Set<string>(NODE_TABLES as readonly string[]); @@ -135,13 +135,13 @@ export const loadGraphToKuzu = async ( // Format: "from","to","type",confidence,"reason",step const match = line.match(/"([^"]*)","([^"]*)","([^"]*)",([0-9.]+),"([^"]*)",([0-9-]+)/); if (!match) continue; - + const [, fromId, toId, relType, confidenceStr, reason, stepStr] = match; const fromLabel = getNodeLabel(fromId); const toLabel = getNodeLabel(toId); - // Skip relationships where either node's label doesn't have a table in KuzuDB + // Skip relationships where either node's label doesn't have a table in LadybugDB // Querying a non-existent table causes a fatal native crash if (!validTables.has(fromLabel) || !validTables.has(toLabel)) { skippedRels++; @@ -150,7 +150,7 @@ export const loadGraphToKuzu = async ( const confidence = parseFloat(confidenceStr) || 1.0; const step = parseInt(stepStr) || 0; - + const insertQuery = ` MATCH (a:${escapeLabel(fromLabel)} {id: '${fromId.replace(/'/g, "''")}'}), (b:${escapeLabel(toLabel)} {id: '${toId.replace(/'/g, "''")}'}) @@ -167,38 +167,39 @@ export const loadGraphToKuzu = async ( const toLabel = getNodeLabel(toId); const key = `${relType}:${fromLabel}->` + toLabel; skippedRelStats.set(key, (skippedRelStats.get(key) || 0) + 1); - + if (import.meta.env.DEV) { console.warn(`⚠️ Skipped: ${key} | "${fromId}" → "${toId}" | ${err instanceof Error ? err.message : String(err)}`); } } } } - + if (import.meta.env.DEV) { - console.log(`KuzuDB: Inserted ${insertedRels}/${relCount} relations`); + console.log(`LadybugDB: Inserted ${insertedRels}/${relCount} relations`); if (skippedRels > 0) { const topSkipped = Array.from(skippedRelStats.entries()) .sort((a, b) => b[1] - a[1]) .slice(0, 10); - console.warn(`KuzuDB: Skipped ${skippedRels}/${relCount} relations (top by kind/pair):`, topSkipped); + console.warn(`LadybugDB: Skipped ${skippedRels}/${relCount} relations (top by kind/pair):`, topSkipped); } } - + // 6. Verify results let totalNodes = 0; for (const tableName of NODE_TABLES) { try { const countRes = await conn.query(`MATCH (n:${tableName}) RETURN count(n) AS cnt`); - const countRow = await countRes.getNext(); + const countRows = await countRes.getAll(); + const countRow = countRows[0]; const count = countRow ? (countRow.cnt ?? countRow[0] ?? 0) : 0; totalNodes += Number(count); } catch { // Table might be empty, skip } } - - if (import.meta.env.DEV) console.log(`✅ KuzuDB Bulk Load Complete. Total nodes: ${totalNodes}, edges: ${insertedRels}`); + + if (import.meta.env.DEV) console.log(`✅ LadybugDB Bulk Load Complete. Total nodes: ${totalNodes}, edges: ${insertedRels}`); // 7. Cleanup CSV files for (const { path } of nodeFiles) { @@ -208,12 +209,12 @@ export const loadGraphToKuzu = async ( return { success: true, count: totalNodes }; } catch (error) { - if (import.meta.env.DEV) console.error('❌ KuzuDB Bulk Load Failed:', error); + if (import.meta.env.DEV) console.error('❌ LadybugDB Bulk Load Failed:', error); return { success: false, count: 0 }; } }; -// KuzuDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes). +// LadybugDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes). // Source code content is full of backslashes which confuse the auto-detection. // We MUST explicitly set ESCAPE='"' and disable auto_detect. const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`; @@ -229,6 +230,9 @@ const escapeTableName = (table: string): string => { return BACKTICK_TABLES.has(table) ? `\`${table}\`` : table; }; +/** Tables with isExported column (TypeScript/JS-native types) */ +const TABLES_WITH_EXPORTED = new Set<string>(['Function', 'Class', 'Interface', 'Method', 'CodeElement']); + /** * Get the COPY query for a node table with correct column mapping */ @@ -246,8 +250,12 @@ const getCopyQuery = (table: NodeTableName, path: string): string => { if (table === 'Process') { return `COPY ${t}(id, label, heuristicLabel, processType, stepCount, communities, entryPointId, terminalId) FROM "${path}" ${COPY_CSV_OPTS}`; } - // Code element tables (Function, Class, Interface, Method, CodeElement, and multi-language) - return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content) FROM "${path}" ${COPY_CSV_OPTS}`; + // TypeScript/JS code element tables have isExported; multi-language tables do not + if (TABLES_WITH_EXPORTED.has(table)) { + return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content) FROM "${path}" ${COPY_CSV_OPTS}`; + } + // Multi-language tables (Struct, Impl, Trait, Macro, etc.) + return `COPY ${t}(id, name, filePath, startLine, endLine, content) FROM "${path}" ${COPY_CSV_OPTS}`; }; /** @@ -256,12 +264,12 @@ const getCopyQuery = (table: NodeTableName, path: string): string => { */ export const executeQuery = async (cypher: string): Promise<any[]> => { if (!conn) { - await initKuzu(); + await initLbug(); } - + try { const result = await conn.query(cypher); - + // Extract column names from RETURN clause const returnMatch = cypher.match(/RETURN\s+(.+?)(?:\s+ORDER|\s+LIMIT|\s+SKIP|\s*$)/is); let columnNames: string[] = []; @@ -284,12 +292,11 @@ export const executeQuery = async (cypher: string): Promise<any[]> => { return col.replace(/[^a-zA-Z0-9_]/g, '_'); }); } - + // Collect all rows + const allRows = await result.getAll(); const rows: any[] = []; - while (await result.hasNext()) { - const row = await result.getNext(); - + for (const row of allRows) { // Convert tuple to named object if we have column names and row is array if (Array.isArray(row) && columnNames.length === row.length) { const namedRow: Record<string, any> = {}; @@ -302,7 +309,7 @@ export const executeQuery = async (cypher: string): Promise<any[]> => { rows.push(row); } } - + return rows; } catch (error) { if (import.meta.env.DEV) console.error('Query execution failed:', error); @@ -313,7 +320,7 @@ export const executeQuery = async (cypher: string): Promise<any[]> => { /** * Get database statistics */ -export const getKuzuStats = async (): Promise<{ nodes: number; edges: number }> => { +export const getLbugStats = async (): Promise<{ nodes: number; edges: number }> => { if (!conn) { return { nodes: 0, edges: 0 }; } @@ -324,43 +331,45 @@ export const getKuzuStats = async (): Promise<{ nodes: number; edges: number }> for (const tableName of NODE_TABLES) { try { const nodeResult = await conn.query(`MATCH (n:${tableName}) RETURN count(n) AS cnt`); - const nodeRow = await nodeResult.getNext(); + const nodeRows = await nodeResult.getAll(); + const nodeRow = nodeRows[0]; totalNodes += Number(nodeRow?.cnt ?? nodeRow?.[0] ?? 0); } catch { // Table might not exist or be empty } } - + // Count edges from single relation table let totalEdges = 0; try { const edgeResult = await conn.query(`MATCH ()-[r:${REL_TABLE_NAME}]->() RETURN count(r) AS cnt`); - const edgeRow = await edgeResult.getNext(); + const edgeRows = await edgeResult.getAll(); + const edgeRow = edgeRows[0]; totalEdges = Number(edgeRow?.cnt ?? edgeRow?.[0] ?? 0); } catch { // Table might not exist or be empty } - + return { nodes: totalNodes, edges: totalEdges }; } catch (error) { if (import.meta.env.DEV) { - console.warn('Failed to get Kuzu stats:', error); + console.warn('Failed to get LadybugDB stats:', error); } return { nodes: 0, edges: 0 }; } }; /** - * Check if KuzuDB is initialized and has data + * Check if LadybugDB is initialized and has data */ -export const isKuzuReady = (): boolean => { +export const isLbugReady = (): boolean => { return conn !== null && db !== null; }; /** * Close the database connection (cleanup) */ -export const closeKuzu = async (): Promise<void> => { +export const closeLbug = async (): Promise<void> => { if (conn) { try { await conn.close(); @@ -373,7 +382,7 @@ export const closeKuzu = async (): Promise<void> => { } catch {} db = null; } - kuzu = null; + lbug = null; }; /** @@ -387,24 +396,20 @@ export const executePrepared = async ( params: Record<string, any> ): Promise<any[]> => { if (!conn) { - await initKuzu(); + await initLbug(); } - + try { const stmt = await conn.prepare(cypher); if (!stmt.isSuccess()) { const errMsg = await stmt.getErrorMessage(); throw new Error(`Prepare failed: ${errMsg}`); } - + const result = await conn.execute(stmt, params); - - const rows: any[] = []; - while (await result.hasNext()) { - const row = await result.getNext(); - rows.push(row); - } - + + const rows = await result.getAll(); + await stmt.close(); return rows; } catch (error) { @@ -421,22 +426,22 @@ export const executeWithReusedStatement = async ( paramsList: Array<Record<string, any>> ): Promise<void> => { if (!conn) { - await initKuzu(); + await initLbug(); } - + if (paramsList.length === 0) return; - + const SUB_BATCH_SIZE = 4; - + for (let i = 0; i < paramsList.length; i += SUB_BATCH_SIZE) { const subBatch = paramsList.slice(i, i + SUB_BATCH_SIZE); - + const stmt = await conn.prepare(cypher); if (!stmt.isSuccess()) { const errMsg = await stmt.getErrorMessage(); throw new Error(`Prepare failed: ${errMsg}`); } - + try { for (const params of subBatch) { await conn.execute(stmt, params); @@ -444,7 +449,7 @@ export const executeWithReusedStatement = async ( } finally { await stmt.close(); } - + if (i + SUB_BATCH_SIZE < paramsList.length) { await new Promise(r => setTimeout(r, 0)); } @@ -456,65 +461,67 @@ export const executeWithReusedStatement = async ( */ export const testArrayParams = async (): Promise<{ success: boolean; error?: string }> => { if (!conn) { - await initKuzu(); + await initLbug(); } - + try { const testEmbedding = new Array(384).fill(0).map((_, i) => i / 384); - + // Get any node ID to test with (try File first, then others) let testNodeId: string | null = null; for (const tableName of NODE_TABLES) { try { const nodeResult = await conn.query(`MATCH (n:${tableName}) RETURN n.id AS id LIMIT 1`); - const nodeRow = await nodeResult.getNext(); + const nodeRows = await nodeResult.getAll(); + const nodeRow = nodeRows[0]; if (nodeRow) { testNodeId = nodeRow.id ?? nodeRow[0]; break; } } catch {} } - + if (!testNodeId) { return { success: false, error: 'No nodes found to test with' }; } - + if (import.meta.env.DEV) { console.log('🧪 Testing array params with node:', testNodeId); } - + // First create an embedding entry const createQuery = `CREATE (e:${EMBEDDING_TABLE_NAME} {nodeId: $nodeId, embedding: $embedding})`; const stmt = await conn.prepare(createQuery); - + if (!stmt.isSuccess()) { const errMsg = await stmt.getErrorMessage(); return { success: false, error: `Prepare failed: ${errMsg}` }; } - + await conn.execute(stmt, { nodeId: testNodeId, embedding: testEmbedding, }); - + await stmt.close(); - + // Verify it was stored const verifyResult = await conn.query( `MATCH (e:${EMBEDDING_TABLE_NAME} {nodeId: '${testNodeId}'}) RETURN e.embedding AS emb` ); - const verifyRow = await verifyResult.getNext(); + const verifyRows = await verifyResult.getAll(); + const verifyRow = verifyRows[0]; const storedEmb = verifyRow?.emb ?? verifyRow?.[0]; - + if (storedEmb && Array.isArray(storedEmb) && storedEmb.length === 384) { if (import.meta.env.DEV) { console.log('✅ Array params WORK! Stored embedding length:', storedEmb.length); } return { success: true }; } else { - return { - success: false, - error: `Embedding not stored correctly. Got: ${typeof storedEmb}, length: ${storedEmb?.length}` + return { + success: false, + error: `Embedding not stored correctly. Got: ${typeof storedEmb}, length: ${storedEmb?.length}` }; } } catch (error) { diff --git a/gitnexus-web/src/core/kuzu/schema.ts b/gitnexus-web/src/core/lbug/schema.ts similarity index 99% rename from gitnexus-web/src/core/kuzu/schema.ts rename to gitnexus-web/src/core/lbug/schema.ts index d74545c069..53a4dab750 100644 --- a/gitnexus-web/src/core/kuzu/schema.ts +++ b/gitnexus-web/src/core/lbug/schema.ts @@ -1,5 +1,5 @@ /** - * KuzuDB Schema Definitions + * LadybugDB Schema Definitions * * Hybrid Schema: * - Separate node tables for each code element type (File, Function, Class, etc.) diff --git a/gitnexus-web/src/core/llm/tools.ts b/gitnexus-web/src/core/llm/tools.ts index 879e451fcb..6fd11478af 100644 --- a/gitnexus-web/src/core/llm/tools.ts +++ b/gitnexus-web/src/core/llm/tools.ts @@ -17,7 +17,7 @@ import { z } from 'zod'; import { WebGPUNotAvailableError, embedText, embeddingToArray, initEmbedder, isEmbedderReady } from '../embeddings/embedder'; /** - * Tool factory - creates tools bound to the KuzuDB query functions + * Tool factory - creates tools bound to the LadybugDB query functions */ export const createGraphRAGTools = ( executeQuery: (cypher: string) => Promise<any[]>, @@ -975,7 +975,7 @@ MATCH (n:Function {id: emb.nodeId}) RETURN n`, // For code elements (Function, Class, etc.), use the direct id const isFileTarget = targetType === 'File'; - // Query each depth level separately (KuzuDB doesn't support list comprehensions on paths) + // Query each depth level separately (LadybugDB doesn't support list comprehensions on paths) // For depth 1: direct connections only // For depth 2+: chain multiple single-hop queries const depthQueries: Promise<any[]>[] = []; diff --git a/gitnexus-web/src/core/llm/types.ts b/gitnexus-web/src/core/llm/types.ts index 21de11b13c..8e43673fa2 100644 --- a/gitnexus-web/src/core/llm/types.ts +++ b/gitnexus-web/src/core/llm/types.ts @@ -224,7 +224,7 @@ export interface AgentStep { * Graph schema information for LLM context */ export const GRAPH_SCHEMA_DESCRIPTION = ` -KUZU GRAPH DATABASE SCHEMA (Multi-Table): +LADYBUG GRAPH DATABASE SCHEMA (Multi-Table): NODE TABLES: 1. File - Source files diff --git a/gitnexus-web/src/core/tree-sitter/parser-loader.ts b/gitnexus-web/src/core/tree-sitter/parser-loader.ts index d5224ca4e0..44bc7c37d6 100644 --- a/gitnexus-web/src/core/tree-sitter/parser-loader.ts +++ b/gitnexus-web/src/core/tree-sitter/parser-loader.ts @@ -39,6 +39,10 @@ const getWasmPath = (language: SupportedLanguages, filePath?: string): string => [SupportedLanguages.CSharp]: '/wasm/csharp/tree-sitter-csharp.wasm', [SupportedLanguages.Go]: '/wasm/go/tree-sitter-go.wasm', [SupportedLanguages.Rust]: '/wasm/rust/tree-sitter-rust.wasm', + [SupportedLanguages.PHP]: '/wasm/php/tree-sitter-php.wasm', + [SupportedLanguages.Ruby]: '/wasm/ruby/tree-sitter-ruby.wasm', + [SupportedLanguages.Kotlin]: '', // Kotlin WASM parser not yet available for web + [SupportedLanguages.Swift]: '/wasm/swift/tree-sitter-swift.wasm', }; return languageFileMap[language]; diff --git a/gitnexus-web/src/hooks/useAppState.tsx b/gitnexus-web/src/hooks/useAppState.tsx index b240401577..233a710ee0 100644 --- a/gitnexus-web/src/hooks/useAppState.tsx +++ b/gitnexus-web/src/hooks/useAppState.tsx @@ -11,7 +11,8 @@ import type { LLMSettings, ProviderConfig, AgentStreamChunk, ChatMessage, ToolCa import { loadSettings, getActiveProviderConfig, saveSettings } from '../core/llm/settings-service'; import type { AgentMessage } from '../core/llm/agent'; import { DEFAULT_VISIBLE_EDGES, type EdgeType } from '../lib/constants'; -import { runCypherQuery, getBackendUrl } from '../services/backend'; +import type { RepoSummary, ConnectToServerResult } from '../services/server-connection'; +import { fetchRepos, connectToServer } from '../services/server-connection'; export type ViewMode = 'onboarding' | 'loading' | 'exploring'; export type RightPanelTab = 'code' | 'chat'; @@ -112,6 +113,13 @@ interface AppState { projectName: string; setProjectName: (name: string) => void; + // Multi-repo switching + serverBaseUrl: string | null; + setServerBaseUrl: (url: string | null) => void; + availableRepos: RepoSummary[]; + setAvailableRepos: (repos: RepoSummary[]) => void; + switchRepo: (repoName: string) => Promise<void>; + // Worker API (shared across app) runPipeline: (file: File, onProgress: (p: PipelineProgress) => void, clusteringConfig?: ProviderConfig) => Promise<PipelineResult>; runPipelineFromFiles: (files: FileEntry[], onProgress: (p: PipelineProgress) => void, clusteringConfig?: ProviderConfig) => Promise<PipelineResult>; @@ -161,12 +169,6 @@ interface AppState { clearAICodeReferences: () => void; clearCodeReferences: () => void; codeReferenceFocus: CodeReferenceFocus | null; - - // Backend mode - isBackendMode: boolean; - backendRepo: string | null; - setBackendMode: (mode: boolean) => void; - setBackendRepo: (repo: string | null) => void; } const AppStateContext = createContext<AppState | null>(null); @@ -277,6 +279,10 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { // Project info const [projectName, setProjectName] = useState<string>(''); + // Multi-repo switching + const [serverBaseUrl, setServerBaseUrl] = useState<string | null>(null); + const [availableRepos, setAvailableRepos] = useState<RepoSummary[]>([]); + // Embedding state const [embeddingStatus, setEmbeddingStatus] = useState<EmbeddingStatus>('idle'); const [embeddingProgress, setEmbeddingProgress] = useState<EmbeddingProgress | null>(null); @@ -298,11 +304,7 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { const [isCodePanelOpen, setCodePanelOpen] = useState(false); const [codeReferenceFocus, setCodeReferenceFocus] = useState<CodeReferenceFocus | null>(null); - // Backend mode - const [isBackendMode, setIsBackendMode] = useState(false); - const [backendRepo, setBackendRepo] = useState<string | null>(null); - - const normalizePath = useCallback((p: string) => { + const normalizePath = useCallback((p: string) => { return p.replace(/\\/g, '/').replace(/^\.?\//, ''); }, []); @@ -465,16 +467,12 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { }, []); const runQuery = useCallback(async (cypher: string): Promise<any[]> => { - if (isBackendMode && backendRepo) { - return runCypherQuery(backendRepo, cypher); - } const api = apiRef.current; if (!api) throw new Error('Worker not initialized'); return api.runQuery(cypher); - }, [isBackendMode, backendRepo]); + }, []); const isDatabaseReady = useCallback(async (): Promise<boolean> => { - if (isBackendMode) return true; // backend handles DB const api = apiRef.current; if (!api) return false; try { @@ -482,13 +480,10 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { } catch { return false; } - }, [isBackendMode]); + }, []); // Embedding methods const startEmbeddings = useCallback(async (forceDevice?: 'webgpu' | 'wasm'): Promise<void> => { - // Embeddings require the WASM worker DB — skip in backend mode - if (isBackendMode) return; - const api = apiRef.current; if (!api) throw new Error('Worker not initialized'); @@ -530,7 +525,7 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { } throw error; } - }, [isBackendMode]); + }, []); const semanticSearch = useCallback(async ( query: string, @@ -571,39 +566,25 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { }, []); const initializeAgent = useCallback(async (overrideProjectName?: string): Promise<void> => { - const config = getActiveProviderConfig(); - if (!config) { - setAgentError('Please configure an LLM provider in settings'); - return; - } - const api = apiRef.current; if (!api) { setAgentError('Worker not initialized'); return; } + const config = getActiveProviderConfig(); + if (!config) { + setAgentError('Please configure an LLM provider in settings'); + return; + } + setIsAgentInitializing(true); setAgentError(null); try { + // Use override if provided (for fresh loads), fallback to state (for re-init) const effectiveProjectName = overrideProjectName || projectName || 'project'; - let result: { success: boolean; error?: string }; - - if (isBackendMode && backendRepo) { - // Backend mode: pass HTTP config + file contents to worker - const entries = Array.from(fileContents.entries()); - result = await api.initializeBackendAgent( - config, - getBackendUrl(), - backendRepo, - entries, - effectiveProjectName, - ); - } else { - result = await api.initializeAgent(config, effectiveProjectName); - } - + const result = await api.initializeAgent(config, effectiveProjectName); if (result.success) { setIsAgentReady(true); setAgentError(null); @@ -621,7 +602,7 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { } finally { setIsAgentInitializing(false); } - }, [projectName, isBackendMode, backendRepo, fileContents]); + }, [projectName]); const sendChatMessage = useCallback(async (message: string): Promise<void> => { const api = apiRef.current; @@ -991,6 +972,73 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { setAgentError(null); }, []); + // Switch to a different repo on the connected server + const switchRepo = useCallback(async (repoName: string) => { + if (!serverBaseUrl) return; + + setProgress({ phase: 'extracting', percent: 0, message: 'Switching repository...', detail: `Loading ${repoName}` }); + setViewMode('loading'); + + // Clear stale graph state from previous repo (highlights, selections, blast radius) + // Without this, sigma reducers dim ALL nodes/edges because old node IDs don't match + setHighlightedNodeIds(new Set()); + clearAIToolHighlights(); + clearBlastRadius(); + setSelectedNode(null); + setQueryResult(null); + setCodeReferences([]); + setCodePanelOpen(false); + setCodeReferenceFocus(null); + + try { + const result: ConnectToServerResult = await connectToServer(serverBaseUrl, (phase, downloaded, total) => { + if (phase === 'validating') { + setProgress({ phase: 'extracting', percent: 5, message: 'Switching repository...', detail: 'Validating' }); + } else if (phase === 'downloading') { + const pct = total ? Math.round((downloaded / total) * 90) + 5 : 50; + const mb = (downloaded / (1024 * 1024)).toFixed(1); + setProgress({ phase: 'extracting', percent: pct, message: 'Downloading graph...', detail: `${mb} MB downloaded` }); + } else if (phase === 'extracting') { + setProgress({ phase: 'extracting', percent: 97, message: 'Processing...', detail: 'Extracting file contents' }); + } + }, undefined, repoName); + + // Reuse the same handleServerConnect logic inline + const repoPath = result.repoInfo.repoPath; + const pName = result.repoInfo.name || repoPath.split('/').pop() || 'server-project'; + setProjectName(pName); + + const graph = createKnowledgeGraph(); + for (const node of result.nodes) graph.addNode(node); + for (const rel of result.relationships) graph.addRelationship(rel); + setGraph(graph); + + const fileMap = new Map<string, string>(); + for (const [p, c] of Object.entries(result.fileContents)) fileMap.set(p, c); + setFileContents(fileMap); + + setViewMode('exploring'); + + if (getActiveProviderConfig()) initializeAgent(pName); + + startEmbeddings().catch((err) => { + if (err?.name === 'WebGPUNotAvailableError' || err?.message?.includes('WebGPU')) { + startEmbeddings('wasm').catch(console.warn); + } else { + console.warn('Embeddings auto-start failed:', err); + } + }); + } catch (err) { + console.error('Repo switch failed:', err); + setProgress({ + phase: 'error', percent: 0, + message: 'Failed to switch repository', + detail: err instanceof Error ? err.message : 'Unknown error', + }); + setTimeout(() => { setViewMode('exploring'); setProgress(null); }, 3000); + } + }, [serverBaseUrl, setProgress, setViewMode, setProjectName, setGraph, setFileContents, initializeAgent, startEmbeddings, setHighlightedNodeIds, clearAIToolHighlights, clearBlastRadius, setSelectedNode, setQueryResult, setCodeReferences, setCodePanelOpen, setCodeReferenceFocus]); + const removeCodeReference = useCallback((id: string) => { setCodeReferences(prev => { const ref = prev.find(r => r.id === id); @@ -1084,6 +1132,12 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { setProgress, projectName, setProjectName, + // Multi-repo switching + serverBaseUrl, + setServerBaseUrl, + availableRepos, + setAvailableRepos, + switchRepo, runPipeline, runPipelineFromFiles, runQuery, @@ -1124,11 +1178,6 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => { clearAICodeReferences, clearCodeReferences, codeReferenceFocus, - // Backend mode - isBackendMode, - backendRepo, - setBackendMode: setIsBackendMode, - setBackendRepo, }; return ( diff --git a/gitnexus-web/src/services/server-connection.ts b/gitnexus-web/src/services/server-connection.ts new file mode 100644 index 0000000000..8c262000b9 --- /dev/null +++ b/gitnexus-web/src/services/server-connection.ts @@ -0,0 +1,157 @@ +import { GraphNode, GraphRelationship } from '../core/graph/types'; + +export interface RepoSummary { + name: string; + path: string; + indexedAt: string; + lastCommit: string; + stats: { + files: number; + nodes: number; + edges: number; + communities: number; + processes: number; + }; +} + +export interface ServerRepoInfo { + name: string; + repoPath: string; + indexedAt: string; + stats: { + files: number; + nodes: number; + edges: number; + communities: number; + processes: number; + }; +} + +export interface ConnectToServerResult { + nodes: GraphNode[]; + relationships: GraphRelationship[]; + fileContents: Record<string, string>; + repoInfo: ServerRepoInfo; +} + +export function normalizeServerUrl(input: string): string { + let url = input.trim(); + + // Strip trailing slashes + url = url.replace(/\/+$/, ''); + + // Add protocol if missing + if (!url.startsWith('http://') && !url.startsWith('https://')) { + if (url.startsWith('localhost') || url.startsWith('127.0.0.1')) { + url = `http://${url}`; + } else { + url = `https://${url}`; + } + } + + // Add /api if not already present + if (!url.endsWith('/api')) { + url = `${url}/api`; + } + + return url; +} + +export async function fetchRepos(baseUrl: string): Promise<RepoSummary[]> { + const response = await fetch(`${baseUrl}/repos`); + if (!response.ok) throw new Error(`Server returned ${response.status}`); + return response.json(); +} + +export async function fetchRepoInfo(baseUrl: string, repoName?: string): Promise<ServerRepoInfo> { + const url = repoName ? `${baseUrl}/repo?repo=${encodeURIComponent(repoName)}` : `${baseUrl}/repo`; + const response = await fetch(url); + if (!response.ok) { + throw new Error(`Server returned ${response.status}: ${response.statusText}`); + } + const data = await response.json(); + // npm gitnexus@1.3.3 returns "path"; git HEAD returns "repoPath" + return { ...data, repoPath: data.repoPath ?? data.path }; +} + +export async function fetchGraph( + baseUrl: string, + onProgress?: (downloaded: number, total: number | null) => void, + signal?: AbortSignal, + repoName?: string +): Promise<{ nodes: GraphNode[]; relationships: GraphRelationship[] }> { + const url = repoName ? `${baseUrl}/graph?repo=${encodeURIComponent(repoName)}` : `${baseUrl}/graph`; + const response = await fetch(url, { signal }); + if (!response.ok) { + throw new Error(`Server returned ${response.status}: ${response.statusText}`); + } + + const contentLength = response.headers.get('Content-Length'); + const total = contentLength ? parseInt(contentLength, 10) : null; + + if (!response.body) { + const data = await response.json(); + return data; + } + + const reader = response.body.getReader(); + const chunks: Uint8Array[] = []; + let downloaded = 0; + + while (true) { + const { done, value } = await reader.read(); + if (done) break; + + chunks.push(value); + downloaded += value.length; + onProgress?.(downloaded, total); + } + + const combined = new Uint8Array(downloaded); + let offset = 0; + for (const chunk of chunks) { + combined.set(chunk, offset); + offset += chunk.length; + } + + const text = new TextDecoder().decode(combined); + return JSON.parse(text); +} + +export function extractFileContents(nodes: GraphNode[]): Record<string, string> { + const contents: Record<string, string> = {}; + for (const node of nodes) { + if (node.label === 'File' && (node.properties as any).content) { + contents[node.properties.filePath] = (node.properties as any).content; + } + } + return contents; +} + +export async function connectToServer( + url: string, + onProgress?: (phase: string, downloaded: number, total: number | null) => void, + signal?: AbortSignal, + repoName?: string +): Promise<ConnectToServerResult> { + const baseUrl = normalizeServerUrl(url); + + // Phase 1: Validate server + onProgress?.('validating', 0, null); + const repoInfo = await fetchRepoInfo(baseUrl, repoName); + + // Phase 2: Download graph + onProgress?.('downloading', 0, null); + const { nodes, relationships } = await fetchGraph( + baseUrl, + (downloaded, total) => onProgress?.('downloading', downloaded, total), + signal, + repoName + ); + + // Phase 3: Extract file contents + onProgress?.('extracting', 0, null); + const fileContents = extractFileContents(nodes); + + return { nodes, relationships, fileContents, repoInfo }; +} diff --git a/gitnexus-web/src/types/kuzu-wasm.d.ts b/gitnexus-web/src/types/lbug-wasm.d.ts similarity index 56% rename from gitnexus-web/src/types/kuzu-wasm.d.ts rename to gitnexus-web/src/types/lbug-wasm.d.ts index 51148100e6..3e4d71486e 100644 --- a/gitnexus-web/src/types/kuzu-wasm.d.ts +++ b/gitnexus-web/src/types/lbug-wasm.d.ts @@ -1,28 +1,35 @@ -declare module 'kuzu-wasm' { +declare module '@ladybugdb/wasm-core' { export function init(): Promise<void>; export class Database { - constructor(path: string); + constructor(path: string, bufferPoolSize?: number); close(): Promise<void>; } export class Connection { constructor(db: Database); query(cypher: string): Promise<QueryResult>; + prepare(cypher: string): Promise<PreparedStatement>; + execute(stmt: PreparedStatement, params?: Record<string, any>): Promise<QueryResult>; close(): Promise<void>; } export interface QueryResult { + getAll(): Promise<any[]>; hasNext(): Promise<boolean>; getNext(): Promise<any>; } + export interface PreparedStatement { + isSuccess(): boolean; + getErrorMessage(): Promise<string>; + close(): Promise<void>; + } export const FS: { writeFile(path: string, data: string): Promise<void>; unlink(path: string): Promise<void>; }; - const kuzu: { + const lbug: { init: typeof init; Database: typeof Database; Connection: typeof Connection; FS: typeof FS; }; - export default kuzu; + export default lbug; } - diff --git a/gitnexus-web/src/workers/ingestion.worker.ts b/gitnexus-web/src/workers/ingestion.worker.ts index 2de63ee3de..0f36d85771 100644 --- a/gitnexus-web/src/workers/ingestion.worker.ts +++ b/gitnexus-web/src/workers/ingestion.worker.ts @@ -26,13 +26,13 @@ import { type HybridSearchResult, } from '../core/search'; -// Lazy import for Kuzu to avoid breaking worker if SharedArrayBuffer unavailable -let kuzuAdapter: typeof import('../core/kuzu/kuzu-adapter') | null = null; -const getKuzuAdapter = async () => { - if (!kuzuAdapter) { - kuzuAdapter = await import('../core/kuzu/kuzu-adapter'); +// Lazy import for LadybugDB to avoid breaking worker if SharedArrayBuffer unavailable +let lbugAdapter: typeof import('../core/lbug/lbug-adapter') | null = null; +const getLbugAdapter = async () => { + if (!lbugAdapter) { + lbugAdapter = await import('../core/lbug/lbug-adapter'); } - return kuzuAdapter; + return lbugAdapter; }; // Embedding state @@ -172,52 +172,52 @@ const workerApi = { console.log(`🔍 BM25 index built: ${bm25DocCount} documents`); } - // Load graph into KuzuDB for querying (optional - gracefully degrades) + // Load graph into LadybugDB for querying (optional - gracefully degrades) try { onProgress({ phase: 'complete', percent: 98, - message: 'Loading into KuzuDB...', + message: 'Loading into LadybugDB...', stats: { filesProcessed: result.graph.nodeCount, totalFiles: result.graph.nodeCount, nodesCreated: result.graph.nodeCount, }, }); - - const kuzu = await getKuzuAdapter(); - await kuzu.loadGraphToKuzu(result.graph, result.fileContents); - + + const lbug = await getLbugAdapter(); + await lbug.loadGraphToLbug(result.graph, result.fileContents); + if (import.meta.env.DEV) { - const stats = await kuzu.getKuzuStats(); - console.log('KuzuDB loaded:', stats); + const stats = await lbug.getLbugStats(); + console.log('LadybugDB loaded:', stats); console.log('📁 Stored', storedFileContents.size, 'files for grep/read tools'); } } catch { - // KuzuDB is optional - silently continue without it + // LadybugDB is optional - silently continue without it } - + // Store clustering config for background enrichment (runs after graph loads) if (clusteringConfig) { pendingEnrichmentConfig = clusteringConfig; console.log('📋 Clustering config saved for background enrichment'); } - + // Convert to serializable format for transfer back to main thread return serializePipelineResult(result); }, /** - * Execute a Cypher query against the KuzuDB database + * Execute a Cypher query against the LadybugDB database * @param cypher - The Cypher query string * @returns Query results as an array of objects */ async runQuery(cypher: string): Promise<any[]> { - const kuzu = await getKuzuAdapter(); - if (!kuzu.isKuzuReady()) { + const lbug = await getLbugAdapter(); + if (!lbug.isLbugReady()) { throw new Error('Database not ready. Please load a repository first.'); } - return kuzu.executeQuery(cypher); + return lbug.executeQuery(cypher); }, /** @@ -225,8 +225,8 @@ const workerApi = { */ async isReady(): Promise<boolean> { try { - const kuzu = await getKuzuAdapter(); - return kuzu.isKuzuReady(); + const lbug = await getLbugAdapter(); + return lbug.isLbugReady(); } catch { return false; } @@ -237,8 +237,8 @@ const workerApi = { */ async getStats(): Promise<{ nodes: number; edges: number }> { try { - const kuzu = await getKuzuAdapter(); - return kuzu.getKuzuStats(); + const lbug = await getLbugAdapter(); + return lbug.getLbugStats(); } catch { return { nodes: 0, edges: 0 }; } @@ -276,29 +276,29 @@ const workerApi = { console.log(`🔍 BM25 index built: ${bm25DocCount} documents`); } - // Load graph into KuzuDB for querying (optional - gracefully degrades) + // Load graph into LadybugDB for querying (optional - gracefully degrades) try { onProgress({ phase: 'complete', percent: 98, - message: 'Loading into KuzuDB...', + message: 'Loading into LadybugDB...', stats: { filesProcessed: result.graph.nodeCount, totalFiles: result.graph.nodeCount, nodesCreated: result.graph.nodeCount, }, }); - - const kuzu = await getKuzuAdapter(); - await kuzu.loadGraphToKuzu(result.graph, result.fileContents); - + + const lbug = await getLbugAdapter(); + await lbug.loadGraphToLbug(result.graph, result.fileContents); + if (import.meta.env.DEV) { - const stats = await kuzu.getKuzuStats(); - console.log('KuzuDB loaded:', stats); + const stats = await lbug.getLbugStats(); + console.log('LadybugDB loaded:', stats); console.log('📁 Stored', storedFileContents.size, 'files for grep/read tools'); } } catch { - // KuzuDB is optional - silently continue without it + // LadybugDB is optional - silently continue without it } // Store clustering config for background enrichment (runs after graph loads) @@ -325,8 +325,8 @@ const workerApi = { onProgress: (progress: EmbeddingProgress) => void, forceDevice?: 'webgpu' | 'wasm' ): Promise<void> { - const kuzu = await getKuzuAdapter(); - if (!kuzu.isKuzuReady()) { + const lbug = await getLbugAdapter(); + if (!lbug.isLbugReady()) { throw new Error('Database not ready. Please load a repository first.'); } @@ -343,8 +343,8 @@ const workerApi = { }; await runEmbeddingPipeline( - kuzu.executeQuery, - kuzu.executeWithReusedStatement, + lbug.executeQuery, + lbug.executeWithReusedStatement, progressCallback, forceDevice ? { device: forceDevice } : {} ); @@ -400,15 +400,15 @@ const workerApi = { k: number = 10, maxDistance: number = 0.5 ): Promise<SemanticSearchResult[]> { - const kuzu = await getKuzuAdapter(); - if (!kuzu.isKuzuReady()) { + const lbug = await getLbugAdapter(); + if (!lbug.isLbugReady()) { throw new Error('Database not ready. Please load a repository first.'); } if (!isEmbeddingComplete) { throw new Error('Embeddings not ready. Please wait for embedding pipeline to complete.'); } - return doSemanticSearch(kuzu.executeQuery, query, k, maxDistance); + return doSemanticSearch(lbug.executeQuery, query, k, maxDistance); }, /** @@ -424,15 +424,15 @@ const workerApi = { k: number = 5, hops: number = 2 ): Promise<any[]> { - const kuzu = await getKuzuAdapter(); - if (!kuzu.isKuzuReady()) { + const lbug = await getLbugAdapter(); + if (!lbug.isLbugReady()) { throw new Error('Database not ready. Please load a repository first.'); } if (!isEmbeddingComplete) { throw new Error('Embeddings not ready. Please wait for embedding pipeline to complete.'); } - return doSemanticSearchWithContext(kuzu.executeQuery, query, k, hops); + return doSemanticSearchWithContext(lbug.executeQuery, query, k, hops); }, /** @@ -458,9 +458,9 @@ const workerApi = { let semanticResults: SemanticSearchResult[] = []; if (isEmbeddingComplete) { try { - const kuzu = await getKuzuAdapter(); - if (kuzu.isKuzuReady()) { - semanticResults = await doSemanticSearch(kuzu.executeQuery, query, k * 3, 0.5); + const lbug = await getLbugAdapter(); + if (lbug.isLbugReady()) { + semanticResults = await doSemanticSearch(lbug.executeQuery, query, k * 3, 0.5); } } catch { // Semantic search failed, continue with BM25 only @@ -516,15 +516,15 @@ const workerApi = { }, /** - * Test if KuzuDB supports array parameters in prepared statements + * Test if LadybugDB supports array parameters in prepared statements * This is a diagnostic function */ async testArrayParams(): Promise<{ success: boolean; error?: string }> { - const kuzu = await getKuzuAdapter(); - if (!kuzu.isKuzuReady()) { + const lbug = await getLbugAdapter(); + if (!lbug.isLbugReady()) { return { success: false, error: 'Database not ready' }; } - return kuzu.testArrayParams(); + return lbug.testArrayParams(); }, // ============================================================ @@ -539,8 +539,8 @@ const workerApi = { */ async initializeAgent(config: ProviderConfig, projectName?: string): Promise<{ success: boolean; error?: string }> { try { - const kuzu = await getKuzuAdapter(); - if (!kuzu.isKuzuReady()) { + const lbug = await getLbugAdapter(); + if (!lbug.isLbugReady()) { return { success: false, error: 'Database not ready. Please load a repository first.' }; } @@ -549,31 +549,31 @@ const workerApi = { if (!isEmbeddingComplete) { throw new Error('Embeddings not ready'); } - return doSemanticSearch(kuzu.executeQuery, query, k, maxDistance); + return doSemanticSearch(lbug.executeQuery, query, k, maxDistance); }; const semanticSearchWithContextWrapper = async (query: string, k?: number, hops?: number) => { if (!isEmbeddingComplete) { throw new Error('Embeddings not ready'); } - return doSemanticSearchWithContext(kuzu.executeQuery, query, k, hops); + return doSemanticSearchWithContext(lbug.executeQuery, query, k, hops); }; // Hybrid search wrapper - combines BM25 + semantic const hybridSearchWrapper = async (query: string, k?: number) => { // Get BM25 results (always available after ingestion) const bm25Results = searchBM25(query, (k ?? 10) * 3); - + // Get semantic results if embeddings are ready let semanticResults: any[] = []; if (isEmbeddingComplete) { try { - semanticResults = await doSemanticSearch(kuzu.executeQuery, query, (k ?? 10) * 3, 0.5); + semanticResults = await doSemanticSearch(lbug.executeQuery, query, (k ?? 10) * 3, 0.5); } catch { // Semantic search failed, continue with BM25 only } } - + // Merge with RRF return mergeWithRRF(bm25Results, semanticResults, k ?? 10); }; @@ -586,7 +586,7 @@ const workerApi = { let codebaseContext; try { - codebaseContext = await buildCodebaseContext(kuzu.executeQuery, resolvedProjectName); + codebaseContext = await buildCodebaseContext(lbug.executeQuery, resolvedProjectName); if (import.meta.env.DEV) { console.log('📊 Codebase context built:', { files: codebaseContext.stats.fileCount, @@ -600,7 +600,7 @@ const workerApi = { currentAgent = createGraphRAGAgent( config, - kuzu.executeQuery, + lbug.executeQuery, semanticSearchWrapper, semanticSearchWithContextWrapper, hybridSearchWrapper, @@ -627,7 +627,7 @@ const workerApi = { /** * Initialize the Graph RAG agent in backend mode (HTTP-backed tools). - * Uses HTTP wrappers instead of local KuzuDB for all tool queries. + * Uses HTTP wrappers instead of local LadybugDB for all tool queries. * @param config - Provider configuration for the LLM * @param backendUrl - Base URL of the gitnexus serve backend * @param repoName - Repository name on the backend @@ -848,9 +848,9 @@ const workerApi = { } }); - // Update KuzuDB with new data + // Update LadybugDB with new data try { - const kuzu = await getKuzuAdapter(); + const lbug = await getLbugAdapter(); onProgress(enrichments.size, enrichments.size); // Done @@ -872,11 +872,11 @@ const workerApi = { c.enrichedBy = "llm" `; - await kuzu.executeQuery(query); + await lbug.executeQuery(query); } - + } catch (err) { - console.error('Failed to update KuzuDB with enrichment:', err); + console.error('Failed to update LadybugDB with enrichment:', err); } // Convert Map to Record for serialization diff --git a/gitnexus-web/vite.config.ts b/gitnexus-web/vite.config.ts index ba0aa08399..16b9b4f3ad 100644 --- a/gitnexus-web/vite.config.ts +++ b/gitnexus-web/vite.config.ts @@ -12,11 +12,11 @@ export default defineConfig({ tailwindcss(), wasm(), topLevelAwait(), - // Copy kuzu-wasm worker file to assets folder for production + // Copy lbug-wasm worker file to assets folder for production viteStaticCopy({ targets: [ { - src: 'node_modules/kuzu-wasm/kuzu_wasm_worker.js', + src: 'node_modules/@ladybugdb/wasm-core/lbug_wasm_worker.js', dest: 'assets' } ] @@ -35,12 +35,12 @@ export default defineConfig({ define: { global: 'globalThis', }, - // Optimize deps - exclude kuzu-wasm from pre-bundling (it has WASM files) + // Optimize deps - exclude lbug-wasm from pre-bundling (it has WASM files) optimizeDeps: { - exclude: ['kuzu-wasm'], + exclude: ['@ladybugdb/wasm-core'], include: ['buffer'], }, - // Required for KuzuDB WASM (SharedArrayBuffer needs Cross-Origin Isolation) + // Required for LadybugDB WASM (SharedArrayBuffer needs Cross-Origin Isolation) server: { headers: { 'Cross-Origin-Opener-Policy': 'same-origin', diff --git a/gitnexus/.claude/settings.local.json b/gitnexus/.claude/settings.local.json new file mode 100644 index 0000000000..5ce0c2d701 --- /dev/null +++ b/gitnexus/.claude/settings.local.json @@ -0,0 +1,7 @@ +{ + "permissions": { + "allow": [ + "mcp__plugin_claude-mem_mcp-search__get_observations" + ] + } +} diff --git a/gitnexus/CHANGELOG.md b/gitnexus/CHANGELOG.md new file mode 100644 index 0000000000..c7bcf67c4a --- /dev/null +++ b/gitnexus/CHANGELOG.md @@ -0,0 +1,72 @@ +# Changelog + +All notable changes to GitNexus will be documented in this file. + +## [1.4.6] - 2026-03-18 + +### Added +- **Phase 7 type resolution** — return-aware loop inference for call-expression iterables (#341) + - `ReturnTypeLookup` interface with `lookupReturnType` / `lookupRawReturnType` split + - `ForLoopExtractorContext` context object replacing positional `(node, env)` signature + - Call-expression iterable resolution across 8 languages (TS/JS, Java, Kotlin, C#, Go, Rust, Python, PHP) + - PHP `$this->property` foreach via `@var` class property scan (Strategy C) + - PHP `function_call_expression` and `member_call_expression` foreach paths + - `extractElementTypeFromString` as canonical raw-string container unwrapper in `shared.ts` + - `extractReturnTypeName` deduplicated from `call-processor.ts` into `shared.ts` (137 lines removed) + - `SKIP_SUBTREE_TYPES` performance optimization with documented `template_string` exclusion + - `pendingCallResults` infrastructure (dormant — Phase 9 work) + +### Fixed +- **impact**: return structured error + partial results instead of crashing (#345) +- **impact**: add `HAS_METHOD` and `OVERRIDES` to `VALID_RELATION_TYPES` (#350) +- **cli**: write tool output to stdout via fd 1 instead of stderr (#346) +- **postinstall**: add permission fix for CLI and hook scripts (#348) +- **workflow**: use prefixed temporary branch name for fork PRs to prevent overwriting real branches +- **test**: add `--repo` to CLI e2e tool tests for multi-repo environment +- **php**: add `declaration_list` type guard on `findClassPropertyElementType` fallback +- **docs**: correct `pendingCallResults` description in roadmap and system docs + +### Chore +- Add `.worktrees/` to `.gitignore` + +## [1.4.5] - 2026-03-17 + +### Added +- **Ruby language support** for CLI and web (#111) +- **TypeEnvironment API** with constructor inference, self/this/super resolution (#274) +- **Return type inference** with doc-comment parsing (JSDoc, PHPDoc, YARD) and per-language type extractors (#284) +- **Phase 4 type resolution** — nullable unwrapping, for-loop typing, assignment chain propagation (#310) +- **Phase 5 type resolution** — chained calls, pattern matching, class-as-receiver (#315) +- **Phase 6 type resolution** — for-loop Tier 1c, pattern matching, container descriptors, 10-language coverage (#318) + - Container descriptor table for generic type argument resolution (Map keys vs values) + - Method-aware for-loop extractors with integration tests for all languages + - Recursive pattern binding (C# `is` patterns, Kotlin `when/is` smart casts) + - Class field declaration unwrapping for C#/Java + - PHP `$this->property` foreach member access + - C++ pointer dereference range-for + - Java `this.data.values()` field access patterns + - Position-indexed when/is bindings for branch-local narrowing +- **Type resolution system documentation** with architecture guide and roadmap +- `.gitignore` and `.gitnexusignore` support during file discovery (#231) +- Codex MCP configuration documentation in README (#236) +- `skipGraphPhases` pipeline option to skip MRO/community/process phases for faster test runs +- `hookTimeout: 120000` in vitest config for CI beforeAll hooks + +### Changed +- **Migrated from KuzuDB to LadybugDB v0.15** (#275) +- Dynamically discover and install agent skills in CLI (#270) + +### Performance +- Worker pool threshold — skip worker creation for small repos (<15 files or <512KB total) +- AST walk pruning via `SKIP_SUBTREE_TYPES` for leaf-only nodes (string, comment, number literals) +- Pre-computed `interestingNodeTypes` set — single Set.has() replaces 3 checks per AST node +- `fastStripNullable` — skip full nullable parsing for simple identifiers (90%+ case) +- Replace `.children?.find()` with manual for loops in `extractFunctionName` to eliminate array allocations + +### Fixed +- Same-directory Python import resolution (#328) +- Ruby method-level call resolution, HAS_METHOD edges, and dispatch table (#278) +- C++ fixture file casing for case-sensitive CI +- Template string incorrectly included in AST pruning set (contains interpolated expressions) + +## [1.4.0] - Previous release diff --git a/gitnexus/Dockerfile.test b/gitnexus/Dockerfile.test new file mode 100644 index 0000000000..9d68cf2d47 --- /dev/null +++ b/gitnexus/Dockerfile.test @@ -0,0 +1,9 @@ +FROM node:22-bookworm +WORKDIR /app +RUN apt-get update && apt-get install -y python3 make g++ && rm -rf /var/lib/apt/lists/* +COPY . . +RUN npm ci --ignore-scripts \ + && node scripts/patch-tree-sitter-swift.cjs \ + && (npm rebuild 2>&1 || true) \ + && cd node_modules/tree-sitter-kotlin && npx --yes node-gyp rebuild 2>&1 +CMD ["npx", "vitest", "run", "test/integration", "--reporter=verbose"] diff --git a/gitnexus/README.md b/gitnexus/README.md index 16383afe69..e4fe5b6230 100644 --- a/gitnexus/README.md +++ b/gitnexus/README.md @@ -103,7 +103,7 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas 5. **Processes** — Traces execution flows from entry points through call chains 6. **Search** — Builds hybrid search indexes for fast retrieval -The result is a **KuzuDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings. +The result is a **LadybugDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings. ## MCP Tools @@ -146,7 +146,8 @@ Your AI agent gets these tools automatically: gitnexus setup # Configure MCP for your editors (one-time) gitnexus analyze [path] # Index a repository (or update stale index) gitnexus analyze --force # Force full re-index -gitnexus analyze --skip-embeddings # Skip embedding generation (faster) +gitnexus analyze --embeddings # Enable embedding generation (slower, better search) +gitnexus analyze --verbose # Log skipped files when parsers are unavailable gitnexus mcp # Start MCP server (stdio) — serves all indexed repos gitnexus serve # Start local HTTP server (multi-repo) for web UI gitnexus list # List all indexed repositories @@ -163,7 +164,27 @@ GitNexus supports indexing multiple repositories. Each `gitnexus analyze` regist ## Supported Languages -TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust +TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift, Ruby + +### Language Feature Matrix + +| Language | Imports | Named Bindings | Exports | Heritage | Type Annotations | Constructor Inference | Config | Frameworks | Entry Points | +|----------|---------|----------------|---------|----------|-----------------|---------------------|--------|------------|-------------| +| TypeScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| JavaScript | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | +| Python | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| Java | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | +| Kotlin | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | +| C# | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| Go | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| Rust | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | +| PHP | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | +| Ruby | ✓ | — | ✓ | ✓ | — | ✓ | — | ✓ | ✓ | +| Swift | — | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| C | — | — | ✓ | — | ✓ | ✓ | — | ✓ | ✓ | +| C++ | — | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | + +**Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics ## Agent Skills diff --git a/gitnexus/hooks/claude/gitnexus-hook.cjs b/gitnexus/hooks/claude/gitnexus-hook.cjs old mode 100644 new mode 100755 index 3b2e5f508e..55e694fa2b --- a/gitnexus/hooks/claude/gitnexus-hook.cjs +++ b/gitnexus/hooks/claude/gitnexus-hook.cjs @@ -2,8 +2,10 @@ /** * GitNexus Claude Code Hook * - * PreToolUse handler — intercepts Grep/Glob/Bash searches - * and augments with graph context from the GitNexus index. + * PreToolUse — intercepts Grep/Glob/Bash searches and augments + * with graph context from the GitNexus index. + * PostToolUse — detects stale index after git mutations and notifies + * the agent to reindex. * * NOTE: SessionStart hooks are broken on Windows (Claude Code bug). * Session context is injected via CLAUDE.md / skills instead. @@ -11,7 +13,7 @@ const fs = require('fs'); const path = require('path'); -const { execFileSync } = require('child_process'); +const { spawnSync } = require('child_process'); /** * Read JSON input from stdin synchronously. @@ -26,19 +28,19 @@ function readInput() { } /** - * Check if a directory (or ancestor) has a .gitnexus index. + * Find the .gitnexus directory by walking up from startDir. + * Returns the path to .gitnexus/ or null if not found. */ -function findGitNexusIndex(startDir) { +function findGitNexusDir(startDir) { let dir = startDir || process.cwd(); for (let i = 0; i < 5; i++) { - if (fs.existsSync(path.join(dir, '.gitnexus'))) { - return true; - } + const candidate = path.join(dir, '.gitnexus'); + if (fs.existsSync(candidate)) return candidate; const parent = path.dirname(dir); if (parent === dir) break; dir = parent; } - return false; + return null; } /** @@ -83,52 +85,153 @@ function extractPattern(toolName, toolInput) { return null; } +/** + * Resolve the gitnexus CLI path. + * 1. Relative path (works when script is inside npm package) + * 2. require.resolve (works when gitnexus is globally installed) + * 3. Fall back to npx (returns empty string) + */ +function resolveCliPath() { + let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js'); + if (!fs.existsSync(cliPath)) { + try { + cliPath = require.resolve('gitnexus/dist/cli/index.js'); + } catch { + cliPath = ''; + } + } + return cliPath; +} + +/** + * Spawn a gitnexus CLI command synchronously. + * Returns the stderr output (KuzuDB captures stdout at OS level). + */ +function runGitNexusCli(cliPath, args, cwd, timeout) { + const isWin = process.platform === 'win32'; + if (cliPath) { + return spawnSync( + process.execPath, + [cliPath, ...args], + { encoding: 'utf-8', timeout, cwd, stdio: ['pipe', 'pipe', 'pipe'] } + ); + } + // On Windows, invoke npx.cmd directly (no shell needed) + return spawnSync( + isWin ? 'npx.cmd' : 'npx', + ['-y', 'gitnexus', ...args], + { encoding: 'utf-8', timeout: timeout + 5000, cwd, stdio: ['pipe', 'pipe', 'pipe'] } + ); +} + +/** + * PreToolUse handler — augment searches with graph context. + */ +function handlePreToolUse(input) { + const cwd = input.cwd || process.cwd(); + if (!path.isAbsolute(cwd)) return; + if (!findGitNexusDir(cwd)) return; + + const toolName = input.tool_name || ''; + const toolInput = input.tool_input || {}; + + if (toolName !== 'Grep' && toolName !== 'Glob' && toolName !== 'Bash') return; + + const pattern = extractPattern(toolName, toolInput); + if (!pattern || pattern.length < 3) return; + + const cliPath = resolveCliPath(); + let result = ''; + try { + const child = runGitNexusCli(cliPath, ['augment', '--', pattern], cwd, 7000); + if (!child.error && child.status === 0) { + result = child.stderr || ''; + } + } catch { /* graceful failure */ } + + if (result && result.trim()) { + sendHookResponse('PreToolUse', result.trim()); + } +} + +/** + * Emit a PostToolUse hook response with additional context for the agent. + */ +function sendHookResponse(hookEventName, message) { + console.log(JSON.stringify({ + hookSpecificOutput: { hookEventName, additionalContext: message } + })); +} + +/** + * PostToolUse handler — detect index staleness after git mutations. + * + * Instead of spawning a full `gitnexus analyze` synchronously (which blocks + * the agent for up to 120s and risks KuzuDB corruption on timeout), we do a + * lightweight staleness check: compare `git rev-parse HEAD` against the + * lastCommit stored in `.gitnexus/meta.json`. If they differ, notify the + * agent so it can decide when to reindex. + */ +function handlePostToolUse(input) { + const toolName = input.tool_name || ''; + if (toolName !== 'Bash') return; + + const command = (input.tool_input || {}).command || ''; + if (!/\bgit\s+(commit|merge|rebase|cherry-pick|pull)(\s|$)/.test(command)) return; + + // Only proceed if the command succeeded + const toolOutput = input.tool_output || {}; + if (toolOutput.exit_code !== undefined && toolOutput.exit_code !== 0) return; + + const cwd = input.cwd || process.cwd(); + if (!path.isAbsolute(cwd)) return; + const gitNexusDir = findGitNexusDir(cwd); + if (!gitNexusDir) return; + + // Compare HEAD against last indexed commit — skip if unchanged + let currentHead = ''; + try { + const headResult = spawnSync('git', ['rev-parse', 'HEAD'], { + encoding: 'utf-8', timeout: 3000, cwd, stdio: ['pipe', 'pipe', 'pipe'], + }); + currentHead = (headResult.stdout || '').trim(); + } catch { return; } + + if (!currentHead) return; + + let lastCommit = ''; + let hadEmbeddings = false; + try { + const meta = JSON.parse(fs.readFileSync(path.join(gitNexusDir, 'meta.json'), 'utf-8')); + lastCommit = meta.lastCommit || ''; + hadEmbeddings = (meta.stats && meta.stats.embeddings > 0); + } catch { /* no meta — treat as stale */ } + + // If HEAD matches last indexed commit, no reindex needed + if (currentHead && currentHead === lastCommit) return; + + const analyzeCmd = `npx gitnexus analyze${hadEmbeddings ? ' --embeddings' : ''}`; + sendHookResponse('PostToolUse', + `GitNexus index is stale (last indexed: ${lastCommit ? lastCommit.slice(0, 7) : 'never'}). ` + + `Run \`${analyzeCmd}\` to update the knowledge graph.` + ); +} + +// Dispatch map for hook events +const handlers = { + PreToolUse: handlePreToolUse, + PostToolUse: handlePostToolUse, +}; + function main() { try { const input = readInput(); - const hookEvent = input.hook_event_name || ''; - - if (hookEvent !== 'PreToolUse') return; - - const cwd = input.cwd || process.cwd(); - if (!findGitNexusIndex(cwd)) return; - - const toolName = input.tool_name || ''; - const toolInput = input.tool_input || {}; - - if (toolName !== 'Grep' && toolName !== 'Glob' && toolName !== 'Bash') return; - - const pattern = extractPattern(toolName, toolInput); - if (!pattern || pattern.length < 3) return; - - // Resolve CLI path relative to this hook script (same package) - // hooks/claude/gitnexus-hook.cjs → dist/cli/index.js - const cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js'); - - // augment CLI writes result to stderr (KuzuDB's native module captures - // stdout fd at OS level, making it unusable in subprocess contexts). - const { spawnSync } = require('child_process'); - let result = ''; - try { - const child = spawnSync( - process.execPath, - [cliPath, 'augment', pattern], - { encoding: 'utf-8', timeout: 8000, cwd, stdio: ['pipe', 'pipe', 'pipe'] } - ); - result = child.stderr || ''; - } catch { /* graceful failure */ } - - if (result && result.trim()) { - console.log(JSON.stringify({ - hookSpecificOutput: { - hookEventName: 'PreToolUse', - additionalContext: result.trim() - } - })); - } + const handler = handlers[input.hook_event_name || '']; + if (handler) handler(input); } catch (err) { - // Graceful failure — log to stderr for debugging - console.error('GitNexus hook error:', err.message); + if (process.env.GITNEXUS_DEBUG) { + console.error('GitNexus hook error:', (err.message || '').slice(0, 200)); + } } } diff --git a/gitnexus/hooks/claude/pre-tool-use.sh b/gitnexus/hooks/claude/pre-tool-use.sh old mode 100644 new mode 100755 index 3c1af3bc0c..96efbaaffe --- a/gitnexus/hooks/claude/pre-tool-use.sh +++ b/gitnexus/hooks/claude/pre-tool-use.sh @@ -63,7 +63,8 @@ if [ "$found" = false ]; then fi # Run gitnexus augment — must be fast (<500ms target) -RESULT=$(cd "$CWD" && npx -y gitnexus augment "$PATTERN" 2>/dev/null) +# augment writes to stderr (KuzuDB captures stdout at OS level), so capture stderr and discard stdout +RESULT=$(cd "$CWD" && npx -y gitnexus augment "$PATTERN" 2>&1 1>/dev/null) if [ -n "$RESULT" ]; then ESCAPED=$(echo "$RESULT" | jq -Rs .) diff --git a/gitnexus/hooks/claude/session-start.sh b/gitnexus/hooks/claude/session-start.sh old mode 100644 new mode 100755 diff --git a/gitnexus/package-lock.json b/gitnexus/package-lock.json index b937d11b9d..c1d9897551 100644 --- a/gitnexus/package-lock.json +++ b/gitnexus/package-lock.json @@ -1,15 +1,17 @@ { "name": "gitnexus", - "version": "1.2.9", + "version": "1.4.6", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "gitnexus", - "version": "1.2.9", + "version": "1.4.6", + "hasInstallScript": true, "license": "PolyForm-Noncommercial-1.0.0", "dependencies": { "@huggingface/transformers": "^3.0.0", + "@ladybugdb/core": "^0.15.2", "@modelcontextprotocol/sdk": "^1.0.0", "cli-progress": "^3.12.0", "commander": "^12.0.0", @@ -19,7 +21,7 @@ "graphology": "^0.25.4", "graphology-indices": "^0.17.0", "graphology-utils": "^2.3.0", - "kuzu": "^0.11.3", + "ignore": "^7.0.5", "lru-cache": "^11.0.0", "mnemonist": "^0.39.0", "pandemonium": "^2.4.0", @@ -30,10 +32,11 @@ "tree-sitter-go": "^0.21.0", "tree-sitter-java": "^0.21.0", "tree-sitter-javascript": "^0.21.0", + "tree-sitter-php": "^0.23.12", "tree-sitter-python": "^0.21.0", + "tree-sitter-ruby": "^0.23.1", "tree-sitter-rust": "^0.21.0", "tree-sitter-typescript": "^0.21.0", - "typescript": "^5.4.5", "uuid": "^13.0.0" }, "bin": { @@ -45,10 +48,77 @@ "@types/express": "^4.17.21", "@types/node": "^20.0.0", "@types/uuid": "^10.0.0", - "tsx": "^4.0.0" + "@vitest/coverage-v8": "^4.0.18", + "tsx": "^4.0.0", + "typescript": "^5.4.5", + "vitest": "^4.0.18" }, "engines": { "node": ">=18.0.0" + }, + "optionalDependencies": { + "tree-sitter-kotlin": "^0.3.8", + "tree-sitter-swift": "^0.6.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz", + "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bcoe/v8-coverage": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz", + "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" } }, "node_modules/@emnapi/runtime": { @@ -1051,6 +1121,219 @@ "node": ">=18.0.0" } }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@ladybugdb/core": { + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/@ladybugdb/core/-/core-0.15.2.tgz", + "integrity": "sha512-DpseEj9CM/QTV0z+rvBk6nB2mOoG4GVhnKKLiXChGTVddgpH6R/Pv2YiDZB7rUIDnFpJxVQNbQaYEkZ7i1h1KA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "cmake-js": "^8.0.0", + "node-addon-api": "^6.0.0" + }, + "optionalDependencies": { + "@ladybugdb/core-darwin-arm64": "0.15.2", + "@ladybugdb/core-linux-arm64": "0.15.2", + "@ladybugdb/core-linux-x64": "0.15.2", + "@ladybugdb/core-win32-x64": "0.15.2" + } + }, + "node_modules/@ladybugdb/core-darwin-arm64": { + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/@ladybugdb/core-darwin-arm64/-/core-darwin-arm64-0.15.2.tgz", + "integrity": "sha512-ifLyUTPzlh2zR1IqkUT5AfldX+X4zfWBzwakmGTgMPxyrEiRNDwUKfnNxHeLQ/TJTOS/nfzYxxLLt5CZf2/FhA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@ladybugdb/core-linux-arm64": { + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/@ladybugdb/core-linux-arm64/-/core-linux-arm64-0.15.2.tgz", + "integrity": "sha512-9537UbHOiuSr/BaTfjcoBsHxEKF4uEXWyXEjm/AQCGXQFocX3nQDVNDYJzuDYjKZ51oJRJ0oSuesAStOCwjolA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@ladybugdb/core-linux-x64": { + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/@ladybugdb/core-linux-x64/-/core-linux-x64-0.15.2.tgz", + "integrity": "sha512-1+xLoapjbMQzDHxcPpMPt8Suuvms3nhOIZFNGPDcWz90NwEmLAjWNFQZZHeg8DRz0vG2j8UY292bvGORVcxs8g==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@ladybugdb/core-win32-x64": { + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/@ladybugdb/core-win32-x64/-/core-win32-x64-0.15.2.tgz", + "integrity": "sha512-+LIJVKBNSrf2bGruJO4l0ihrLKZkv5+lNitK8xc3T7gC1bcc+FaYtRMvlgZP6Qh2rEHAjqfbaSKVrdw0M2EXTw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@ladybugdb/core/node_modules/chownr": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz", + "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==", + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=18" + } + }, + "node_modules/@ladybugdb/core/node_modules/cmake-js": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/cmake-js/-/cmake-js-8.0.0.tgz", + "integrity": "sha512-YbUP88RDwCvoQkZhRtGURYm9RIpWdtvZuhT87fKNoLjk8kIFIFeARpKfuZQGdwfH99GZpUmqSfcDrK62X7lTgg==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.3", + "fs-extra": "^11.3.3", + "node-api-headers": "^1.8.0", + "rc": "1.2.8", + "semver": "^7.7.3", + "tar": "^7.5.6", + "url-join": "^4.0.1", + "which": "^6.0.0", + "yargs": "^17.7.2" + }, + "bin": { + "cmake-js": "bin/cmake-js" + }, + "engines": { + "node": "^20.17.0 || >=22.9.0" + } + }, + "node_modules/@ladybugdb/core/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@ladybugdb/core/node_modules/isexe": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz", + "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==", + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=20" + } + }, + "node_modules/@ladybugdb/core/node_modules/minizlib": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz", + "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==", + "license": "MIT", + "dependencies": { + "minipass": "^7.1.2" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@ladybugdb/core/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/@ladybugdb/core/node_modules/tar": { + "version": "7.5.11", + "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.11.tgz", + "integrity": "sha512-ChjMH33/KetonMTAtpYdgUFr0tbz69Fp2v7zWxQfYZX4g5ZN2nOBXm1R2xyA+lMIKrLKIoKAwFj93jE/avX9cQ==", + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/fs-minipass": "^4.0.0", + "chownr": "^3.0.0", + "minipass": "^7.1.2", + "minizlib": "^3.1.0", + "yallist": "^5.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@ladybugdb/core/node_modules/which": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz", + "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==", + "license": "ISC", + "dependencies": { + "isexe": "^4.0.0" + }, + "bin": { + "node-which": "bin/which.js" + }, + "engines": { + "node": "^20.17.0 || >=22.9.0" + } + }, + "node_modules/@ladybugdb/core/node_modules/yallist": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz", + "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==", + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=18" + } + }, "node_modules/@modelcontextprotocol/sdk": { "version": "1.25.3", "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.25.3.tgz", @@ -1439,6 +1722,363 @@ "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==", "license": "BSD-3-Clause" }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz", + "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz", + "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz", + "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz", + "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz", + "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz", + "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz", + "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz", + "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz", + "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz", + "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz", + "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz", + "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz", + "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz", + "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz", + "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz", + "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz", + "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz", + "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz", + "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz", + "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz", + "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz", + "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz", + "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz", + "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz", + "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@standard-schema/spec": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", + "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/body-parser": { "version": "1.19.6", "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz", @@ -1450,6 +2090,17 @@ "@types/node": "*" } }, + "node_modules/@types/chai": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + } + }, "node_modules/@types/cli-progress": { "version": "3.11.6", "resolved": "https://registry.npmjs.org/@types/cli-progress/-/cli-progress-3.11.6.tgz", @@ -1480,6 +2131,20 @@ "@types/node": "*" } }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/express": { "version": "4.17.25", "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.25.tgz", @@ -1583,6 +2248,148 @@ "dev": true, "license": "MIT" }, + "node_modules/@vitest/coverage-v8": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.0.18.tgz", + "integrity": "sha512-7i+N2i0+ME+2JFZhfuz7Tg/FqKtilHjGyGvoHYQ6iLV0zahbsJ9sljC9OcFcPDbhYKCet+sG8SsVqlyGvPflZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@bcoe/v8-coverage": "^1.0.2", + "@vitest/utils": "4.0.18", + "ast-v8-to-istanbul": "^0.3.10", + "istanbul-lib-coverage": "^3.2.2", + "istanbul-lib-report": "^3.0.1", + "istanbul-reports": "^3.2.0", + "magicast": "^0.5.1", + "obug": "^2.1.1", + "std-env": "^3.10.0", + "tinyrainbow": "^3.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@vitest/browser": "4.0.18", + "vitest": "4.0.18" + }, + "peerDependenciesMeta": { + "@vitest/browser": { + "optional": true + } + } + }, + "node_modules/@vitest/expect": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.18.tgz", + "integrity": "sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.0.0", + "@types/chai": "^5.2.2", + "@vitest/spy": "4.0.18", + "@vitest/utils": "4.0.18", + "chai": "^6.2.1", + "tinyrainbow": "^3.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/mocker": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.18.tgz", + "integrity": "sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "4.0.18", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.21" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^6.0.0 || ^7.0.0-0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/pretty-format": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.18.tgz", + "integrity": "sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^3.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.18.tgz", + "integrity": "sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "4.0.18", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.18.tgz", + "integrity": "sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "4.0.18", + "magic-string": "^0.30.21", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.18.tgz", + "integrity": "sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.18.tgz", + "integrity": "sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "4.0.18", + "tinyrainbow": "^3.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, "node_modules/accepts": { "version": "1.3.8", "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", @@ -1653,47 +2460,32 @@ "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, - "node_modules/aproba": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz", - "integrity": "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==", - "license": "ISC" - }, - "node_modules/are-we-there-yet": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-3.0.1.tgz", - "integrity": "sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==", - "deprecated": "This package is no longer supported.", - "license": "ISC", - "dependencies": { - "delegates": "^1.0.0", - "readable-stream": "^3.6.0" - }, - "engines": { - "node": "^12.13.0 || ^14.15.0 || >=16.0.0" - } - }, "node_modules/array-flatten": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==", "license": "MIT" }, - "node_modules/asynckit": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", - "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", - "license": "MIT" + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } }, - "node_modules/axios": { - "version": "1.13.4", - "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.4.tgz", - "integrity": "sha512-1wVkUaAO6WyaYtCkcYCOx12ZgpGf9Zif+qXa4n+oYzK558YryKqiL6UWwd5DqiH3VRW0GYhTZQ/vlgJrCoNQlg==", + "node_modules/ast-v8-to-istanbul": { + "version": "0.3.12", + "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-0.3.12.tgz", + "integrity": "sha512-BRRC8VRZY2R4Z4lFIL35MwNXmwVqBityvOIwETtsCSwvjl0IdgFsy9NhdaA6j74nUdtJJlIypeRhpDam19Wq3g==", + "dev": true, "license": "MIT", "dependencies": { - "follow-redirects": "^1.15.6", - "form-data": "^4.0.4", - "proxy-from-env": "^1.1.0" + "@jridgewell/trace-mapping": "^0.3.31", + "estree-walker": "^3.0.3", + "js-tokens": "^10.0.0" } }, "node_modules/body-parser": { @@ -1780,13 +2572,14 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/chownr": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", - "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", - "license": "ISC", + "node_modules/chai": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz", + "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=10" + "node": ">=18" } }, "node_modules/cli-progress": { @@ -1929,55 +2722,6 @@ "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, - "node_modules/cmake-js": { - "version": "7.4.0", - "resolved": "https://registry.npmjs.org/cmake-js/-/cmake-js-7.4.0.tgz", - "integrity": "sha512-Lw0JxEHrmk+qNj1n9W9d4IvkDdYTBn7l2BW6XmtLj7WPpIo2shvxUy+YokfjMxAAOELNonQwX3stkPhM5xSC2Q==", - "license": "MIT", - "dependencies": { - "axios": "^1.6.5", - "debug": "^4", - "fs-extra": "^11.2.0", - "memory-stream": "^1.0.0", - "node-api-headers": "^1.1.0", - "npmlog": "^6.0.2", - "rc": "^1.2.7", - "semver": "^7.5.4", - "tar": "^6.2.0", - "url-join": "^4.0.1", - "which": "^2.0.2", - "yargs": "^17.7.2" - }, - "bin": { - "cmake-js": "bin/cmake-js" - }, - "engines": { - "node": ">= 14.15.0" - } - }, - "node_modules/cmake-js/node_modules/debug": { - "version": "4.4.3", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", - "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", - "license": "MIT", - "dependencies": { - "ms": "^2.1.3" - }, - "engines": { - "node": ">=6.0" - }, - "peerDependenciesMeta": { - "supports-color": { - "optional": true - } - } - }, - "node_modules/cmake-js/node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", - "license": "MIT" - }, "node_modules/color-convert": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", @@ -1996,27 +2740,6 @@ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "license": "MIT" }, - "node_modules/color-support": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", - "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", - "license": "ISC", - "bin": { - "color-support": "bin.js" - } - }, - "node_modules/combined-stream": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", - "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", - "license": "MIT", - "dependencies": { - "delayed-stream": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, "node_modules/commander": { "version": "12.1.0", "resolved": "https://registry.npmjs.org/commander/-/commander-12.1.0.tgz", @@ -2026,12 +2749,6 @@ "node": ">=18" } }, - "node_modules/console-control-strings": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", - "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==", - "license": "ISC" - }, "node_modules/content-disposition": { "version": "0.5.4", "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", @@ -2151,21 +2868,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/delayed-stream": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", - "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", - "license": "MIT", - "engines": { - "node": ">=0.4.0" - } - }, - "node_modules/delegates": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", - "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==", - "license": "MIT" - }, "node_modules/depd": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", @@ -2259,6 +2961,13 @@ "node": ">= 0.4" } }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "dev": true, + "license": "MIT" + }, "node_modules/es-object-atoms": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", @@ -2271,21 +2980,6 @@ "node": ">= 0.4" } }, - "node_modules/es-set-tostringtag": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", - "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.6", - "has-tostringtag": "^1.0.2", - "hasown": "^2.0.2" - }, - "engines": { - "node": ">= 0.4" - } - }, "node_modules/es6-error": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz", @@ -2361,6 +3055,16 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, "node_modules/etag": { "version": "1.8.1", "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", @@ -2400,6 +3104,16 @@ "node": ">=18.0.0" } }, + "node_modules/expect-type": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", + "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, "node_modules/express": { "version": "4.22.1", "resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz", @@ -2483,6 +3197,24 @@ ], "license": "BSD-3-Clause" }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, "node_modules/finalhandler": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", @@ -2507,26 +3239,6 @@ "integrity": "sha512-MI1qs7Lo4Syw0EOzUl0xjs2lsoeqFku44KpngfIduHBYvzm8h2+7K8YMQh1JtVVVrUvhLpNwqVi4DERegUJhPQ==", "license": "Apache-2.0" }, - "node_modules/follow-redirects": { - "version": "1.15.11", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz", - "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==", - "funding": [ - { - "type": "individual", - "url": "https://github.com/sponsors/RubenVerborgh" - } - ], - "license": "MIT", - "engines": { - "node": ">=4.0" - }, - "peerDependenciesMeta": { - "debug": { - "optional": true - } - } - }, "node_modules/foreground-child": { "version": "3.3.1", "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", @@ -2543,22 +3255,6 @@ "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/form-data": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz", - "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==", - "license": "MIT", - "dependencies": { - "asynckit": "^0.4.0", - "combined-stream": "^1.0.8", - "es-set-tostringtag": "^2.1.0", - "hasown": "^2.0.2", - "mime-types": "^2.1.12" - }, - "engines": { - "node": ">= 6" - } - }, "node_modules/forwarded": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", @@ -2591,30 +3287,6 @@ "node": ">=14.14" } }, - "node_modules/fs-minipass": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", - "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", - "license": "ISC", - "dependencies": { - "minipass": "^3.0.0" - }, - "engines": { - "node": ">= 8" - } - }, - "node_modules/fs-minipass/node_modules/minipass": { - "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", - "license": "ISC", - "dependencies": { - "yallist": "^4.0.0" - }, - "engines": { - "node": ">=8" - } - }, "node_modules/fsevents": { "version": "2.3.3", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", @@ -2639,73 +3311,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/gauge": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/gauge/-/gauge-4.0.4.tgz", - "integrity": "sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==", - "deprecated": "This package is no longer supported.", - "license": "ISC", - "dependencies": { - "aproba": "^1.0.3 || ^2.0.0", - "color-support": "^1.1.3", - "console-control-strings": "^1.1.0", - "has-unicode": "^2.0.1", - "signal-exit": "^3.0.7", - "string-width": "^4.2.3", - "strip-ansi": "^6.0.1", - "wide-align": "^1.1.5" - }, - "engines": { - "node": "^12.13.0 || ^14.15.0 || >=16.0.0" - } - }, - "node_modules/gauge/node_modules/ansi-regex": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", - "license": "MIT", - "engines": { - "node": ">=8" - } - }, - "node_modules/gauge/node_modules/emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "license": "MIT" - }, - "node_modules/gauge/node_modules/signal-exit": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", - "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", - "license": "ISC" - }, - "node_modules/gauge/node_modules/string-width": { - "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", - "license": "MIT", - "dependencies": { - "emoji-regex": "^8.0.0", - "is-fullwidth-code-point": "^3.0.0", - "strip-ansi": "^6.0.1" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/gauge/node_modules/strip-ansi": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", - "license": "MIT", - "dependencies": { - "ansi-regex": "^5.0.1" - }, - "engines": { - "node": ">=8" - } - }, "node_modules/get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", @@ -2887,6 +3492,16 @@ "integrity": "sha512-Y8T4vYhEfwJOTbouREvG+3XDsjr8E3kIr7uf+JZ0BYloFsttiHU0WfvANVsR7TxNUJa/WpCnw/Ino/p+DeBhBQ==", "license": "ISC" }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/has-property-descriptors": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", @@ -2911,27 +3526,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/has-tostringtag": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", - "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", - "license": "MIT", - "dependencies": { - "has-symbols": "^1.0.3" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/has-unicode": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", - "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==", - "license": "ISC" - }, "node_modules/hasown": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", @@ -2954,6 +3548,13 @@ "node": ">=16.9.0" } }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true, + "license": "MIT" + }, "node_modules/http-errors": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", @@ -2986,6 +3587,15 @@ "node": ">=0.10.0" } }, + "node_modules/ignore": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz", + "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, "node_modules/inherits": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", @@ -3028,6 +3638,45 @@ "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", "license": "ISC" }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", + "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", + "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^4.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-reports": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz", + "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/jackspeak": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.1.tgz", @@ -3052,6 +3701,13 @@ "url": "https://github.com/sponsors/panva" } }, + "node_modules/js-tokens": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz", + "integrity": "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==", + "dev": true, + "license": "MIT" + }, "node_modules/json-schema-traverse": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", @@ -3082,18 +3738,6 @@ "graceful-fs": "^4.1.6" } }, - "node_modules/kuzu": { - "version": "0.11.3", - "resolved": "https://registry.npmjs.org/kuzu/-/kuzu-0.11.3.tgz", - "integrity": "sha512-4+hD3Y+YMV3e0uiqTv1/GUal47D04l8qluw1WFWg8Nx3k7rLsHG1Pmq9WHIOlf1742svxQvTYQiuY6oS1qxAZA==", - "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.", - "hasInstallScript": true, - "license": "MIT", - "dependencies": { - "cmake-js": "^7.3.0", - "node-addon-api": "^6.0.0" - } - }, "node_modules/long": { "version": "5.3.2", "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz", @@ -3109,6 +3753,44 @@ "node": "20 || >=22" } }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/magicast": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.2.tgz", + "integrity": "sha512-E3ZJh4J3S9KfwdjZhe2afj6R9lGIN5Pher1pF39UGrXRqq/VDaGVIGN13BjHd2u8B61hArAGOnso7nBOouW3TQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "source-map-js": "^1.2.1" + } + }, + "node_modules/make-dir": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", + "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/matcher": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz", @@ -3139,15 +3821,6 @@ "node": ">= 0.6" } }, - "node_modules/memory-stream": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/memory-stream/-/memory-stream-1.0.0.tgz", - "integrity": "sha512-Wm13VcsPIMdG96dzILfij09PvuS3APtcKNh7M28FsCA/w6+1mjR7hhPmfFNoilX9xU7wTdhsH5lJAm6XNzdtww==", - "license": "MIT", - "dependencies": { - "readable-stream": "^3.4.0" - } - }, "node_modules/merge-descriptors": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", @@ -3232,43 +3905,6 @@ "node": ">=16 || 14 >=14.17" } }, - "node_modules/minizlib": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", - "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", - "license": "MIT", - "dependencies": { - "minipass": "^3.0.0", - "yallist": "^4.0.0" - }, - "engines": { - "node": ">= 8" - } - }, - "node_modules/minizlib/node_modules/minipass": { - "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", - "license": "ISC", - "dependencies": { - "yallist": "^4.0.0" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/mkdirp": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", - "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", - "license": "MIT", - "bin": { - "mkdirp": "bin/cmd.js" - }, - "engines": { - "node": ">=10" - } - }, "node_modules/mnemonist": { "version": "0.39.8", "resolved": "https://registry.npmjs.org/mnemonist/-/mnemonist-0.39.8.tgz", @@ -3284,6 +3920,25 @@ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", "license": "MIT" }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, "node_modules/negotiator": { "version": "0.6.3", "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", @@ -3316,22 +3971,6 @@ "node-gyp-build-test": "build-test.js" } }, - "node_modules/npmlog": { - "version": "6.0.2", - "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-6.0.2.tgz", - "integrity": "sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==", - "deprecated": "This package is no longer supported.", - "license": "ISC", - "dependencies": { - "are-we-there-yet": "^3.0.0", - "console-control-strings": "^1.1.0", - "gauge": "^4.0.3", - "set-blocking": "^2.0.0" - }, - "engines": { - "node": "^12.13.0 || ^14.15.0 || >=16.0.0" - } - }, "node_modules/object-assign": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", @@ -3368,6 +4007,17 @@ "integrity": "sha512-42CPE9AhahZRsMNslczq0ctAEtqk8Eka26QofnqC346BZdHDySk3LWka23LI7ULIw11NmltpiLagIq8gBozxTw==", "license": "MIT" }, + "node_modules/obug": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz", + "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==", + "dev": true, + "funding": [ + "https://github.com/sponsors/sxzz", + "https://opencollective.com/debug" + ], + "license": "MIT" + }, "node_modules/on-finished": { "version": "2.4.1", "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", @@ -3533,6 +4183,33 @@ "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", "license": "MIT" }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/pkce-challenge": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz", @@ -3548,6 +4225,35 @@ "integrity": "sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==", "license": "MIT" }, + "node_modules/postcss": { + "version": "8.5.6", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", + "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, "node_modules/protobufjs": { "version": "7.5.4", "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz", @@ -3585,12 +4291,6 @@ "node": ">= 0.10" } }, - "node_modules/proxy-from-env": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", - "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", - "license": "MIT" - }, "node_modules/qs": { "version": "6.14.1", "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz", @@ -3661,20 +4361,6 @@ "rc": "cli.js" } }, - "node_modules/readable-stream": { - "version": "3.6.2", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", - "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", - "license": "MIT", - "dependencies": { - "inherits": "^2.0.3", - "string_decoder": "^1.1.1", - "util-deprecate": "^1.0.1" - }, - "engines": { - "node": ">= 6" - } - }, "node_modules/require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", @@ -3720,6 +4406,51 @@ "node": ">=8.0" } }, + "node_modules/rollup": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz", + "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.59.0", + "@rollup/rollup-android-arm64": "4.59.0", + "@rollup/rollup-darwin-arm64": "4.59.0", + "@rollup/rollup-darwin-x64": "4.59.0", + "@rollup/rollup-freebsd-arm64": "4.59.0", + "@rollup/rollup-freebsd-x64": "4.59.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.59.0", + "@rollup/rollup-linux-arm-musleabihf": "4.59.0", + "@rollup/rollup-linux-arm64-gnu": "4.59.0", + "@rollup/rollup-linux-arm64-musl": "4.59.0", + "@rollup/rollup-linux-loong64-gnu": "4.59.0", + "@rollup/rollup-linux-loong64-musl": "4.59.0", + "@rollup/rollup-linux-ppc64-gnu": "4.59.0", + "@rollup/rollup-linux-ppc64-musl": "4.59.0", + "@rollup/rollup-linux-riscv64-gnu": "4.59.0", + "@rollup/rollup-linux-riscv64-musl": "4.59.0", + "@rollup/rollup-linux-s390x-gnu": "4.59.0", + "@rollup/rollup-linux-x64-gnu": "4.59.0", + "@rollup/rollup-linux-x64-musl": "4.59.0", + "@rollup/rollup-openbsd-x64": "4.59.0", + "@rollup/rollup-openharmony-arm64": "4.59.0", + "@rollup/rollup-win32-arm64-msvc": "4.59.0", + "@rollup/rollup-win32-ia32-msvc": "4.59.0", + "@rollup/rollup-win32-x64-gnu": "4.59.0", + "@rollup/rollup-win32-x64-msvc": "4.59.0", + "fsevents": "~2.3.2" + } + }, "node_modules/router": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz", @@ -3873,12 +4604,6 @@ "node": ">= 0.8.0" } }, - "node_modules/set-blocking": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", - "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==", - "license": "ISC" - }, "node_modules/setprototypeof": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", @@ -4022,6 +4747,13 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, "node_modules/signal-exit": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", @@ -4034,12 +4766,29 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/sprintf-js": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==", "license": "BSD-3-Clause" }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, "node_modules/statuses": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", @@ -4049,14 +4798,12 @@ "node": ">= 0.8" } }, - "node_modules/string_decoder": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", - "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", - "license": "MIT", - "dependencies": { - "safe-buffer": "~5.2.0" - } + "node_modules/std-env": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz", + "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==", + "dev": true, + "license": "MIT" }, "node_modules/string-width": { "version": "5.1.2", @@ -4163,31 +4910,61 @@ "node": ">=0.10.0" } }, - "node_modules/tar": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz", - "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==", - "deprecated": "Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exhorbitant rates) by contacting i@izs.me", - "license": "ISC", + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", "dependencies": { - "chownr": "^2.0.0", - "fs-minipass": "^2.0.0", - "minipass": "^5.0.0", - "minizlib": "^2.1.1", - "mkdirp": "^1.0.3", - "yallist": "^4.0.0" + "has-flag": "^4.0.0" }, "engines": { - "node": ">=10" + "node": ">=8" } }, - "node_modules/tar/node_modules/minipass": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz", - "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==", - "license": "ISC", + "node_modules/tinybench": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz", + "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=8" + "node": ">=18" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinyrainbow": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz", + "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" } }, "node_modules/toidentifier": { @@ -4266,6 +5043,20 @@ "node": "^18 || ^20 || >= 21" } }, + "node_modules/tree-sitter-cli": { + "version": "0.23.2", + "resolved": "https://registry.npmjs.org/tree-sitter-cli/-/tree-sitter-cli-0.23.2.tgz", + "integrity": "sha512-kPPXprOqREX+C/FgUp2Qpt9jd0vSwn+hOgjzVv/7hapdoWpa+VeWId53rf4oNNd29ikheF12BYtGD/W90feMbA==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "bin": { + "tree-sitter": "cli.js" + }, + "engines": { + "node": ">=12.0.0" + } + }, "node_modules/tree-sitter-cpp": { "version": "0.22.3", "resolved": "https://registry.npmjs.org/tree-sitter-cpp/-/tree-sitter-cpp-0.22.3.tgz", @@ -4378,6 +5169,61 @@ "node": "^18 || ^20 || >= 21" } }, + "node_modules/tree-sitter-kotlin": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/tree-sitter-kotlin/-/tree-sitter-kotlin-0.3.8.tgz", + "integrity": "sha512-A4obq6bjzmYrA+F0JLLoheFPcofFkctNaZSpnDd+GPn1SfVZLY4/GG4C0cYVBTOShuPBGGAOPLM1JWLZQV4m1g==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "dependencies": { + "node-addon-api": "^7.1.0", + "node-gyp-build": "^4.8.0" + }, + "peerDependencies": { + "tree-sitter": "^0.21.0" + }, + "peerDependenciesMeta": { + "tree_sitter": { + "optional": true + } + } + }, + "node_modules/tree-sitter-kotlin/node_modules/node-addon-api": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-7.1.1.tgz", + "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==", + "license": "MIT", + "optional": true + }, + "node_modules/tree-sitter-php": { + "version": "0.23.12", + "resolved": "https://registry.npmjs.org/tree-sitter-php/-/tree-sitter-php-0.23.12.tgz", + "integrity": "sha512-VwkBVOahhC2NYXK/Fuqq30NxuL/6c2hmbxEF4jrB7AyR5rLc7nT27mzF3qoi+pqx9Gy2AbXnGezF7h4MeM6YRA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-addon-api": "^8.2.2", + "node-gyp-build": "^4.8.2" + }, + "peerDependencies": { + "tree-sitter": "^0.21.1" + }, + "peerDependenciesMeta": { + "tree-sitter": { + "optional": true + } + } + }, + "node_modules/tree-sitter-php/node_modules/node-addon-api": { + "version": "8.5.0", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.5.0.tgz", + "integrity": "sha512-/bRZty2mXUIFY/xU5HLvveNHlswNJej+RnxBjOMkidWfwZzgTbPG1E3K5TOxRLOR+5hX7bSofy8yf1hZevMS8A==", + "license": "MIT", + "engines": { + "node": "^18 || ^20 || >= 21" + } + }, "node_modules/tree-sitter-python": { "version": "0.21.0", "resolved": "https://registry.npmjs.org/tree-sitter-python/-/tree-sitter-python-0.21.0.tgz", @@ -4403,6 +5249,34 @@ "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==", "license": "MIT" }, + "node_modules/tree-sitter-ruby": { + "version": "0.23.1", + "resolved": "https://registry.npmjs.org/tree-sitter-ruby/-/tree-sitter-ruby-0.23.1.tgz", + "integrity": "sha512-d9/RXgWjR6HanN7wTYhS5bpBQLz1VkH048Vm3CodPGyJVnamXMGb8oEhDypVCBq4QnHui9sTXuJBBP3WtCw5RA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-addon-api": "^8.2.2", + "node-gyp-build": "^4.8.2" + }, + "peerDependencies": { + "tree-sitter": "^0.21.1" + }, + "peerDependenciesMeta": { + "tree-sitter": { + "optional": true + } + } + }, + "node_modules/tree-sitter-ruby/node_modules/node-addon-api": { + "version": "8.6.0", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.6.0.tgz", + "integrity": "sha512-gBVjCaqDlRUk0EwoPNKzIr9KkS9041G/q31IBShPs1Xz6UTA+EXdZADbzqAJQrpDRq71CIMnOP5VMut3SL0z5Q==", + "license": "MIT", + "engines": { + "node": "^18 || ^20 || >= 21" + } + }, "node_modules/tree-sitter-rust": { "version": "0.21.0", "resolved": "https://registry.npmjs.org/tree-sitter-rust/-/tree-sitter-rust-0.21.0.tgz", @@ -4428,6 +5302,38 @@ "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==", "license": "MIT" }, + "node_modules/tree-sitter-swift": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tree-sitter-swift/-/tree-sitter-swift-0.6.0.tgz", + "integrity": "sha512-9vOJZes4/UFjBr4COHtp6ZHVuZYwfChSQbpneXQog04dAstfx5px3ybVX2cN+ylvLqsvVpmXLpidxxgF2rDQ7A==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "dependencies": { + "node-addon-api": "^8.0.0", + "node-gyp-build": "^4.8.0", + "tree-sitter-cli": "^0.23", + "which": "2.0.2" + }, + "peerDependencies": { + "tree-sitter": "^0.21.1" + }, + "peerDependenciesMeta": { + "tree_sitter": { + "optional": true + } + } + }, + "node_modules/tree-sitter-swift/node_modules/node-addon-api": { + "version": "8.6.0", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.6.0.tgz", + "integrity": "sha512-gBVjCaqDlRUk0EwoPNKzIr9KkS9041G/q31IBShPs1Xz6UTA+EXdZADbzqAJQrpDRq71CIMnOP5VMut3SL0z5Q==", + "license": "MIT", + "optional": true, + "engines": { + "node": "^18 || ^20 || >= 21" + } + }, "node_modules/tree-sitter-typescript": { "version": "0.21.2", "resolved": "https://registry.npmjs.org/tree-sitter-typescript/-/tree-sitter-typescript-0.21.2.tgz", @@ -4521,6 +5427,7 @@ "version": "5.9.3", "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, "license": "Apache-2.0", "bin": { "tsc": "bin/tsc", @@ -4560,12 +5467,6 @@ "integrity": "sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==", "license": "MIT" }, - "node_modules/util-deprecate": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", - "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", - "license": "MIT" - }, "node_modules/utils-merge": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", @@ -4597,6 +5498,159 @@ "node": ">= 0.8" } }, + "node_modules/vite": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz", + "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.27.0", + "fdir": "^6.5.0", + "picomatch": "^4.0.3", + "postcss": "^8.5.6", + "rollup": "^4.43.0", + "tinyglobby": "^0.2.15" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vitest": { + "version": "4.0.18", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.18.tgz", + "integrity": "sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/expect": "4.0.18", + "@vitest/mocker": "4.0.18", + "@vitest/pretty-format": "4.0.18", + "@vitest/runner": "4.0.18", + "@vitest/snapshot": "4.0.18", + "@vitest/spy": "4.0.18", + "@vitest/utils": "4.0.18", + "es-module-lexer": "^1.7.0", + "expect-type": "^1.2.2", + "magic-string": "^0.30.21", + "obug": "^2.1.1", + "pathe": "^2.0.3", + "picomatch": "^4.0.3", + "std-env": "^3.10.0", + "tinybench": "^2.9.0", + "tinyexec": "^1.0.2", + "tinyglobby": "^0.2.15", + "tinyrainbow": "^3.0.3", + "vite": "^6.0.0 || ^7.0.0", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^20.0.0 || ^22.0.0 || >=24.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@opentelemetry/api": "^1.9.0", + "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", + "@vitest/browser-playwright": "4.0.18", + "@vitest/browser-preview": "4.0.18", + "@vitest/browser-webdriverio": "4.0.18", + "@vitest/ui": "4.0.18", + "happy-dom": "*", + "jsdom": "*" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@opentelemetry/api": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser-playwright": { + "optional": true + }, + "@vitest/browser-preview": { + "optional": true + }, + "@vitest/browser-webdriverio": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + } + } + }, "node_modules/which": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", @@ -4612,51 +5666,18 @@ "node": ">= 8" } }, - "node_modules/wide-align": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz", - "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==", - "license": "ISC", - "dependencies": { - "string-width": "^1.0.2 || 2 || 3 || 4" - } - }, - "node_modules/wide-align/node_modules/ansi-regex": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", - "license": "MIT", - "engines": { - "node": ">=8" - } - }, - "node_modules/wide-align/node_modules/emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "license": "MIT" - }, - "node_modules/wide-align/node_modules/string-width": { - "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "node_modules/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, "license": "MIT", "dependencies": { - "emoji-regex": "^8.0.0", - "is-fullwidth-code-point": "^3.0.0", - "strip-ansi": "^6.0.1" + "siginfo": "^2.0.0", + "stackback": "0.0.2" }, - "engines": { - "node": ">=8" - } - }, - "node_modules/wide-align/node_modules/strip-ansi": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", - "license": "MIT", - "dependencies": { - "ansi-regex": "^5.0.1" + "bin": { + "why-is-node-running": "cli.js" }, "engines": { "node": ">=8" @@ -4768,12 +5789,6 @@ "node": ">=10" } }, - "node_modules/yallist": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", - "license": "ISC" - }, "node_modules/yargs": { "version": "17.7.2", "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", diff --git a/gitnexus/package.json b/gitnexus/package.json index 6cbeacab5a..a59e763b92 100644 --- a/gitnexus/package.json +++ b/gitnexus/package.json @@ -1,6 +1,6 @@ { "name": "gitnexus", - "version": "1.2.9", + "version": "1.4.6", "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.", "author": "Abhigyan Patwari", "license": "PolyForm-Noncommercial-1.0.0", @@ -33,13 +33,21 @@ "files": [ "dist", "hooks", + "scripts", "skills", "vendor" ], "scripts": { "build": "tsc", "dev": "tsx watch src/cli/index.ts", - "prepare": "npm run build" + "test": "vitest run", + "test:unit": "vitest run test/unit", + "test:integration": "vitest run test/integration", + "test:watch": "vitest", + "test:coverage": "vitest run --coverage", + "prepare": "npm run build", + "postinstall": "node scripts/patch-tree-sitter-swift.cjs", + "prepack": "npm run build && chmod +x dist/cli/index.js" }, "dependencies": { "@huggingface/transformers": "^3.0.0", @@ -52,7 +60,8 @@ "graphology": "^0.25.4", "graphology-indices": "^0.17.0", "graphology-utils": "^2.3.0", - "kuzu": "^0.11.3", + "@ladybugdb/core": "^0.15.2", + "ignore": "^7.0.5", "lru-cache": "^11.0.0", "mnemonist": "^0.39.0", "pandemonium": "^2.4.0", @@ -63,19 +72,27 @@ "tree-sitter-go": "^0.21.0", "tree-sitter-java": "^0.21.0", "tree-sitter-javascript": "^0.21.0", + "tree-sitter-php": "^0.23.12", "tree-sitter-python": "^0.21.0", + "tree-sitter-ruby": "^0.23.1", "tree-sitter-rust": "^0.21.0", "tree-sitter-typescript": "^0.21.0", - "typescript": "^5.4.5", "uuid": "^13.0.0" }, + "optionalDependencies": { + "tree-sitter-kotlin": "^0.3.8", + "tree-sitter-swift": "^0.6.0" + }, "devDependencies": { "@types/cli-progress": "^3.11.6", "@types/cors": "^2.8.17", "@types/express": "^4.17.21", "@types/node": "^20.0.0", "@types/uuid": "^10.0.0", - "tsx": "^4.0.0" + "@vitest/coverage-v8": "^4.0.18", + "tsx": "^4.0.0", + "typescript": "^5.4.5", + "vitest": "^4.0.18" }, "engines": { "node": ">=18.0.0" diff --git a/gitnexus/scripts/patch-tree-sitter-swift.cjs b/gitnexus/scripts/patch-tree-sitter-swift.cjs new file mode 100755 index 0000000000..3c3dcad505 --- /dev/null +++ b/gitnexus/scripts/patch-tree-sitter-swift.cjs @@ -0,0 +1,74 @@ +#!/usr/bin/env node +/** + * WORKAROUND: tree-sitter-swift@0.6.0 binding.gyp build failure + * + * Background: + * tree-sitter-swift@0.6.0's binding.gyp contains an "actions" array that + * invokes `tree-sitter generate` to regenerate parser.c from grammar.js. + * This is intended for grammar developers, but the published npm package + * already ships pre-generated parser files (parser.c, scanner.c), so the + * actions are unnecessary for consumers. Since consumers don't have + * tree-sitter-cli installed, the actions always fail during `npm install`. + * + * Why we can't just upgrade: + * tree-sitter-swift@0.7.1 fixes this (removes postinstall, ships prebuilds), + * but it requires tree-sitter@^0.22.1. The upstream project pins tree-sitter + * to ^0.21.0 and all other grammar packages depend on that version. + * Upgrading tree-sitter would be a separate breaking change. + * + * How this workaround works: + * 1. tree-sitter-swift's own postinstall fails (npm warns but continues) + * 2. This script runs as gitnexus's postinstall + * 3. It removes the "actions" array from binding.gyp + * 4. It rebuilds the native binding with the cleaned binding.gyp + * + * TODO: Remove this script when tree-sitter is upgraded to ^0.22.x, + * which allows using tree-sitter-swift@0.7.1+ directly. + */ +const fs = require('fs'); +const path = require('path'); +const { execSync } = require('child_process'); + +const swiftDir = path.join(__dirname, '..', 'node_modules', 'tree-sitter-swift'); +const bindingPath = path.join(swiftDir, 'binding.gyp'); + +try { + if (!fs.existsSync(bindingPath)) { + process.exit(0); + } + + const content = fs.readFileSync(bindingPath, 'utf8'); + let needsRebuild = false; + + if (content.includes('"actions"')) { + // Strip Python-style comments (#) before JSON parsing + const cleaned = content.replace(/#[^\n]*/g, ''); + const gyp = JSON.parse(cleaned); + + if (gyp.targets && gyp.targets[0] && gyp.targets[0].actions) { + delete gyp.targets[0].actions; + fs.writeFileSync(bindingPath, JSON.stringify(gyp, null, 2) + '\n'); + console.log('[tree-sitter-swift] Patched binding.gyp (removed actions array)'); + needsRebuild = true; + } + } + + // Check if native binding exists + const bindingNode = path.join(swiftDir, 'build', 'Release', 'tree_sitter_swift_binding.node'); + if (!fs.existsSync(bindingNode)) { + needsRebuild = true; + } + + if (needsRebuild) { + console.log('[tree-sitter-swift] Rebuilding native binding...'); + execSync('npx node-gyp rebuild', { + cwd: swiftDir, + stdio: 'pipe', + timeout: 120000, + }); + console.log('[tree-sitter-swift] Native binding built successfully'); + } +} catch (err) { + console.warn('[tree-sitter-swift] Could not build native binding:', err.message); + console.warn('[tree-sitter-swift] You may need to manually run: cd node_modules/tree-sitter-swift && npx node-gyp rebuild'); +} diff --git a/gitnexus/skills/gitnexus-cli.md b/gitnexus/skills/gitnexus-cli.md new file mode 100644 index 0000000000..c9e0af341a --- /dev/null +++ b/gitnexus/skills/gitnexus-cli.md @@ -0,0 +1,82 @@ +--- +name: gitnexus-cli +description: "Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: \"Index this repo\", \"Reanalyze the codebase\", \"Generate a wiki\"" +--- + +# GitNexus CLI Commands + +All commands work via `npx` — no global install required. + +## Commands + +### analyze — Build or refresh the index + +```bash +npx gitnexus analyze +``` + +Run from the project root. This parses all source files, builds the knowledge graph, writes it to `.gitnexus/`, and generates CLAUDE.md / AGENTS.md context files. + +| Flag | Effect | +| -------------- | ---------------------------------------------------------------- | +| `--force` | Force full re-index even if up to date | +| `--embeddings` | Enable embedding generation for semantic search (off by default) | + +**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale. In Claude Code, a PostToolUse hook runs `analyze` automatically after `git commit` and `git merge`, preserving embeddings if previously generated. + +### status — Check index freshness + +```bash +npx gitnexus status +``` + +Shows whether the current repo has a GitNexus index, when it was last updated, and symbol/relationship counts. Use this to check if re-indexing is needed. + +### clean — Delete the index + +```bash +npx gitnexus clean +``` + +Deletes the `.gitnexus/` directory and unregisters the repo from the global registry. Use before re-indexing if the index is corrupt or after removing GitNexus from a project. + +| Flag | Effect | +| --------- | ------------------------------------------------- | +| `--force` | Skip confirmation prompt | +| `--all` | Clean all indexed repos, not just the current one | + +### wiki — Generate documentation from the graph + +```bash +npx gitnexus wiki +``` + +Generates repository documentation from the knowledge graph using an LLM. Requires an API key (saved to `~/.gitnexus/config.json` on first use). + +| Flag | Effect | +| ------------------- | ----------------------------------------- | +| `--force` | Force full regeneration | +| `--model <model>` | LLM model (default: minimax/minimax-m2.5) | +| `--base-url <url>` | LLM API base URL | +| `--api-key <key>` | LLM API key | +| `--concurrency <n>` | Parallel LLM calls (default: 3) | +| `--gist` | Publish wiki as a public GitHub Gist | + +### list — Show all indexed repos + +```bash +npx gitnexus list +``` + +Lists all repositories registered in `~/.gitnexus/registry.json`. The MCP `list_repos` tool provides the same information. + +## After Indexing + +1. **Read `gitnexus://repo/{name}/context`** to verify the index loaded +2. Use the other GitNexus skills (`exploring`, `debugging`, `impact-analysis`, `refactoring`) for your task + +## Troubleshooting + +- **"Not inside a git repository"**: Run from a directory inside a git repo +- **Index is stale after re-analyzing**: Restart Claude Code to reload the MCP server +- **Embeddings slow**: Omit `--embeddings` (it's off by default) or set `OPENAI_API_KEY` for faster API-based embedding diff --git a/gitnexus/skills/debugging.md b/gitnexus/skills/gitnexus-debugging.md similarity index 76% rename from gitnexus/skills/debugging.md rename to gitnexus/skills/gitnexus-debugging.md index 3b945835bd..9510b97ac3 100644 --- a/gitnexus/skills/debugging.md +++ b/gitnexus/skills/gitnexus-debugging.md @@ -1,11 +1,12 @@ --- name: gitnexus-debugging -description: Trace bugs through call chains using knowledge graph +description: "Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: \"Why is X failing?\", \"Where does this error come from?\", \"Trace this bug\"" --- # Debugging with GitNexus ## When to Use + - "Why is this function failing?" - "Trace where this error comes from" - "Who calls this method?" @@ -37,17 +38,18 @@ description: Trace bugs through call chains using knowledge graph ## Debugging Patterns -| Symptom | GitNexus Approach | -|---------|-------------------| -| Error message | `gitnexus_query` for error text → `context` on throw sites | -| Wrong return value | `context` on the function → trace callees for data flow | -| Intermittent failure | `context` → look for external calls, async deps | -| Performance issue | `context` → find symbols with many callers (hot paths) | -| Recent regression | `detect_changes` to see what your changes affect | +| Symptom | GitNexus Approach | +| -------------------- | ---------------------------------------------------------- | +| Error message | `gitnexus_query` for error text → `context` on throw sites | +| Wrong return value | `context` on the function → trace callees for data flow | +| Intermittent failure | `context` → look for external calls, async deps | +| Performance issue | `context` → find symbols with many callers (hot paths) | +| Recent regression | `detect_changes` to see what your changes affect | ## Tools **gitnexus_query** — find code related to error: + ``` gitnexus_query({query: "payment validation error"}) → Processes: CheckoutFlow, ErrorHandling @@ -55,6 +57,7 @@ gitnexus_query({query: "payment validation error"}) ``` **gitnexus_context** — full context for a suspect: + ``` gitnexus_context({name: "validatePayment"}) → Incoming calls: processCheckout, webhookHandler @@ -63,6 +66,7 @@ gitnexus_context({name: "validatePayment"}) ``` **gitnexus_cypher** — custom call chain traces: + ```cypher MATCH path = (a)-[:CodeRelation {type: 'CALLS'}*1..2]->(b:Function {name: "validatePayment"}) RETURN [n IN nodes(path) | n.name] AS chain diff --git a/gitnexus/skills/exploring.md b/gitnexus/skills/gitnexus-exploring.md similarity index 75% rename from gitnexus/skills/exploring.md rename to gitnexus/skills/gitnexus-exploring.md index 2214c289cd..927a4e4b64 100644 --- a/gitnexus/skills/exploring.md +++ b/gitnexus/skills/gitnexus-exploring.md @@ -1,11 +1,12 @@ --- name: gitnexus-exploring -description: Navigate unfamiliar code using GitNexus knowledge graph +description: "Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: \"How does X work?\", \"What calls this function?\", \"Show me the auth flow\"" --- # Exploring Codebases with GitNexus ## When to Use + - "How does authentication work?" - "What's the project structure?" - "Show me the main components" @@ -37,16 +38,17 @@ description: Navigate unfamiliar code using GitNexus knowledge graph ## Resources -| Resource | What you get | -|----------|-------------| -| `gitnexus://repo/{name}/context` | Stats, staleness warning (~150 tokens) | -| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores (~300 tokens) | -| `gitnexus://repo/{name}/cluster/{name}` | Area members with file paths (~500 tokens) | -| `gitnexus://repo/{name}/process/{name}` | Step-by-step execution trace (~200 tokens) | +| Resource | What you get | +| --------------------------------------- | ------------------------------------------------------- | +| `gitnexus://repo/{name}/context` | Stats, staleness warning (~150 tokens) | +| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores (~300 tokens) | +| `gitnexus://repo/{name}/cluster/{name}` | Area members with file paths (~500 tokens) | +| `gitnexus://repo/{name}/process/{name}` | Step-by-step execution trace (~200 tokens) | ## Tools **gitnexus_query** — find execution flows related to a concept: + ``` gitnexus_query({query: "payment processing"}) → Processes: CheckoutFlow, RefundFlow, WebhookHandler @@ -54,6 +56,7 @@ gitnexus_query({query: "payment processing"}) ``` **gitnexus_context** — 360-degree view of a symbol: + ``` gitnexus_context({name: "validateUser"}) → Incoming calls: loginHandler, apiMiddleware diff --git a/gitnexus/skills/gitnexus-guide.md b/gitnexus/skills/gitnexus-guide.md new file mode 100644 index 0000000000..937ac73d16 --- /dev/null +++ b/gitnexus/skills/gitnexus-guide.md @@ -0,0 +1,64 @@ +--- +name: gitnexus-guide +description: "Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: \"What GitNexus tools are available?\", \"How do I use GitNexus?\"" +--- + +# GitNexus Guide + +Quick reference for all GitNexus MCP tools, resources, and the knowledge graph schema. + +## Always Start Here + +For any task involving code understanding, debugging, impact analysis, or refactoring: + +1. **Read `gitnexus://repo/{name}/context`** — codebase overview + check index freshness +2. **Match your task to a skill below** and **read that skill file** +3. **Follow the skill's workflow and checklist** + +> If step 1 warns the index is stale, run `npx gitnexus analyze` in the terminal first. + +## Skills + +| Task | Skill to read | +| -------------------------------------------- | ------------------- | +| Understand architecture / "How does X work?" | `gitnexus-exploring` | +| Blast radius / "What breaks if I change X?" | `gitnexus-impact-analysis` | +| Trace bugs / "Why is X failing?" | `gitnexus-debugging` | +| Rename / extract / split / refactor | `gitnexus-refactoring` | +| Tools, resources, schema reference | `gitnexus-guide` (this file) | +| Index, status, clean, wiki CLI commands | `gitnexus-cli` | + +## Tools Reference + +| Tool | What it gives you | +| ---------------- | ------------------------------------------------------------------------ | +| `query` | Process-grouped code intelligence — execution flows related to a concept | +| `context` | 360-degree symbol view — categorized refs, processes it participates in | +| `impact` | Symbol blast radius — what breaks at depth 1/2/3 with confidence | +| `detect_changes` | Git-diff impact — what do your current changes affect | +| `rename` | Multi-file coordinated rename with confidence-tagged edits | +| `cypher` | Raw graph queries (read `gitnexus://repo/{name}/schema` first) | +| `list_repos` | Discover indexed repos | + +## Resources Reference + +Lightweight reads (~100-500 tokens) for navigation: + +| Resource | Content | +| ---------------------------------------------- | ----------------------------------------- | +| `gitnexus://repo/{name}/context` | Stats, staleness check | +| `gitnexus://repo/{name}/clusters` | All functional areas with cohesion scores | +| `gitnexus://repo/{name}/cluster/{clusterName}` | Area members | +| `gitnexus://repo/{name}/processes` | All execution flows | +| `gitnexus://repo/{name}/process/{processName}` | Step-by-step trace | +| `gitnexus://repo/{name}/schema` | Graph schema for Cypher | + +## Graph Schema + +**Nodes:** File, Function, Class, Interface, Method, Community, Process +**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS + +```cypher +MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"}) +RETURN caller.name, caller.filePath +``` diff --git a/gitnexus/skills/impact-analysis.md b/gitnexus/skills/gitnexus-impact-analysis.md similarity index 74% rename from gitnexus/skills/impact-analysis.md rename to gitnexus/skills/gitnexus-impact-analysis.md index bb5f51fcc1..e19af280c1 100644 --- a/gitnexus/skills/impact-analysis.md +++ b/gitnexus/skills/gitnexus-impact-analysis.md @@ -1,11 +1,12 @@ --- name: gitnexus-impact-analysis -description: Analyze blast radius before making code changes +description: "Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: \"Is it safe to change X?\", \"What depends on this?\", \"What will break?\"" --- # Impact Analysis with GitNexus ## When to Use + - "Is it safe to change this function?" - "What will break if I modify X?" - "Show me the blast radius" @@ -37,24 +38,25 @@ description: Analyze blast radius before making code changes ## Understanding Output -| Depth | Risk Level | Meaning | -|-------|-----------|---------| -| d=1 | **WILL BREAK** | Direct callers/importers | -| d=2 | LIKELY AFFECTED | Indirect dependencies | -| d=3 | MAY NEED TESTING | Transitive effects | +| Depth | Risk Level | Meaning | +| ----- | ---------------- | ------------------------ | +| d=1 | **WILL BREAK** | Direct callers/importers | +| d=2 | LIKELY AFFECTED | Indirect dependencies | +| d=3 | MAY NEED TESTING | Transitive effects | ## Risk Assessment -| Affected | Risk | -|----------|------| -| <5 symbols, few processes | LOW | -| 5-15 symbols, 2-5 processes | MEDIUM | -| >15 symbols or many processes | HIGH | +| Affected | Risk | +| ------------------------------ | -------- | +| <5 symbols, few processes | LOW | +| 5-15 symbols, 2-5 processes | MEDIUM | +| >15 symbols or many processes | HIGH | | Critical path (auth, payments) | CRITICAL | ## Tools **gitnexus_impact** — the primary tool for symbol blast radius: + ``` gitnexus_impact({ target: "validateUser", @@ -72,6 +74,7 @@ gitnexus_impact({ ``` **gitnexus_detect_changes** — git-diff based impact analysis: + ``` gitnexus_detect_changes({scope: "staged"}) diff --git a/gitnexus/skills/gitnexus-pr-review.md b/gitnexus/skills/gitnexus-pr-review.md new file mode 100644 index 0000000000..e112f47baa --- /dev/null +++ b/gitnexus/skills/gitnexus-pr-review.md @@ -0,0 +1,163 @@ +--- +name: gitnexus-pr-review +description: "Use when the user wants to review a pull request, understand what a PR changes, assess risk of merging, or check for missing test coverage. Examples: \"Review this PR\", \"What does PR #42 change?\", \"Is this PR safe to merge?\"" +--- + +# PR Review with GitNexus + +## When to Use + +- "Review this PR" +- "What does PR #42 change?" +- "Is this safe to merge?" +- "What's the blast radius of this PR?" +- "Are there missing tests for this PR?" +- Reviewing someone else's code changes before merge + +## Workflow + +``` +1. gh pr diff <number> → Get the raw diff +2. gitnexus_detect_changes({scope: "compare", base_ref: "main"}) → Map diff to affected flows +3. For each changed symbol: + gitnexus_impact({target: "<symbol>", direction: "upstream"}) → Blast radius per change +4. gitnexus_context({name: "<key symbol>"}) → Understand callers/callees +5. READ gitnexus://repo/{name}/processes → Check affected execution flows +6. Summarize findings with risk assessment +``` + +> If "Index is stale" → run `npx gitnexus analyze` in terminal before reviewing. + +## Checklist + +``` +- [ ] Fetch PR diff (gh pr diff or git diff base...head) +- [ ] gitnexus_detect_changes to map changes to affected execution flows +- [ ] gitnexus_impact on each non-trivial changed symbol +- [ ] Review d=1 items (WILL BREAK) — are callers updated? +- [ ] gitnexus_context on key changed symbols to understand full picture +- [ ] Check if affected processes have test coverage +- [ ] Assess overall risk level +- [ ] Write review summary with findings +``` + +## Review Dimensions + +| Dimension | How GitNexus Helps | +| --- | --- | +| **Correctness** | `context` shows callers — are they all compatible with the change? | +| **Blast radius** | `impact` shows d=1/d=2/d=3 dependents — anything missed? | +| **Completeness** | `detect_changes` shows all affected flows — are they all handled? | +| **Test coverage** | `impact({includeTests: true})` shows which tests touch changed code | +| **Breaking changes** | d=1 upstream items that aren't updated in the PR = potential breakage | + +## Risk Assessment + +| Signal | Risk | +| --- | --- | +| Changes touch <3 symbols, 0-1 processes | LOW | +| Changes touch 3-10 symbols, 2-5 processes | MEDIUM | +| Changes touch >10 symbols or many processes | HIGH | +| Changes touch auth, payments, or data integrity code | CRITICAL | +| d=1 callers exist outside the PR diff | Potential breakage — flag it | + +## Tools + +**gitnexus_detect_changes** — map PR diff to affected execution flows: + +``` +gitnexus_detect_changes({scope: "compare", base_ref: "main"}) + +→ Changed: 8 symbols in 4 files +→ Affected processes: CheckoutFlow, RefundFlow, WebhookHandler +→ Risk: MEDIUM +``` + +**gitnexus_impact** — blast radius per changed symbol: + +``` +gitnexus_impact({target: "validatePayment", direction: "upstream"}) + +→ d=1 (WILL BREAK): + - processCheckout (src/checkout.ts:42) [CALLS, 100%] + - webhookHandler (src/webhooks.ts:15) [CALLS, 100%] + +→ d=2 (LIKELY AFFECTED): + - checkoutRouter (src/routes/checkout.ts:22) [CALLS, 95%] +``` + +**gitnexus_impact with tests** — check test coverage: + +``` +gitnexus_impact({target: "validatePayment", direction: "upstream", includeTests: true}) + +→ Tests that cover this symbol: + - validatePayment.test.ts [direct] + - checkout.integration.test.ts [via processCheckout] +``` + +**gitnexus_context** — understand a changed symbol's role: + +``` +gitnexus_context({name: "validatePayment"}) + +→ Incoming calls: processCheckout, webhookHandler +→ Outgoing calls: verifyCard, fetchRates +→ Processes: CheckoutFlow (step 3/7), RefundFlow (step 1/5) +``` + +## Example: "Review PR #42" + +``` +1. gh pr diff 42 > /tmp/pr42.diff + → 4 files changed: payments.ts, checkout.ts, types.ts, utils.ts + +2. gitnexus_detect_changes({scope: "compare", base_ref: "main"}) + → Changed symbols: validatePayment, PaymentInput, formatAmount + → Affected processes: CheckoutFlow, RefundFlow + → Risk: MEDIUM + +3. gitnexus_impact({target: "validatePayment", direction: "upstream"}) + → d=1: processCheckout, webhookHandler (WILL BREAK) + → webhookHandler is NOT in the PR diff — potential breakage! + +4. gitnexus_impact({target: "PaymentInput", direction: "upstream"}) + → d=1: validatePayment (in PR), createPayment (NOT in PR) + → createPayment uses the old PaymentInput shape — breaking change! + +5. gitnexus_context({name: "formatAmount"}) + → Called by 12 functions — but change is backwards-compatible (added optional param) + +6. Review summary: + - MEDIUM risk — 3 changed symbols affect 2 execution flows + - BUG: webhookHandler calls validatePayment but isn't updated for new signature + - BUG: createPayment depends on PaymentInput type which changed + - OK: formatAmount change is backwards-compatible + - Tests: checkout.test.ts covers processCheckout path, but no webhook test +``` + +## Review Output Format + +Structure your review as: + +```markdown +## PR Review: <title> + +**Risk: LOW / MEDIUM / HIGH / CRITICAL** + +### Changes Summary +- <N> symbols changed across <M> files +- <P> execution flows affected + +### Findings +1. **[severity]** Description of finding + - Evidence from GitNexus tools + - Affected callers/flows + +### Missing Coverage +- Callers not updated in PR: ... +- Untested flows: ... + +### Recommendation +APPROVE / REQUEST CHANGES / NEEDS DISCUSSION +``` diff --git a/gitnexus/skills/refactoring.md b/gitnexus/skills/gitnexus-refactoring.md similarity index 84% rename from gitnexus/skills/refactoring.md rename to gitnexus/skills/gitnexus-refactoring.md index 23f4d11301..f48cc01bd5 100644 --- a/gitnexus/skills/refactoring.md +++ b/gitnexus/skills/gitnexus-refactoring.md @@ -1,11 +1,12 @@ --- name: gitnexus-refactoring -description: Plan safe refactors using blast radius and dependency mapping +description: "Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: \"Rename this function\", \"Extract this into a module\", \"Refactor this class\", \"Move this to a separate file\"" --- # Refactoring with GitNexus ## When to Use + - "Rename this function safely" - "Extract this into a module" - "Split this service" @@ -26,6 +27,7 @@ description: Plan safe refactors using blast radius and dependency mapping ## Checklists ### Rename Symbol + ``` - [ ] gitnexus_rename({symbol_name: "oldName", new_name: "newName", dry_run: true}) — preview all edits - [ ] Review graph edits (high confidence) and ast_search edits (review carefully) @@ -35,6 +37,7 @@ description: Plan safe refactors using blast radius and dependency mapping ``` ### Extract Module + ``` - [ ] gitnexus_context({name: target}) — see all incoming/outgoing refs - [ ] gitnexus_impact({target, direction: "upstream"}) — find all external callers @@ -45,6 +48,7 @@ description: Plan safe refactors using blast radius and dependency mapping ``` ### Split Function/Service + ``` - [ ] gitnexus_context({name: target}) — understand all callees - [ ] Group callees by responsibility @@ -58,6 +62,7 @@ description: Plan safe refactors using blast radius and dependency mapping ## Tools **gitnexus_rename** — automated multi-file rename: + ``` gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true}) → 12 edits across 8 files @@ -66,6 +71,7 @@ gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_ ``` **gitnexus_impact** — map all dependents first: + ``` gitnexus_impact({target: "validateUser", direction: "upstream"}) → d=1: loginHandler, apiMiddleware, testUtils @@ -73,6 +79,7 @@ gitnexus_impact({target: "validateUser", direction: "upstream"}) ``` **gitnexus_detect_changes** — verify your changes after refactoring: + ``` gitnexus_detect_changes({scope: "all"}) → Changed: 8 files, 12 symbols @@ -81,6 +88,7 @@ gitnexus_detect_changes({scope: "all"}) ``` **gitnexus_cypher** — custom reference queries: + ```cypher MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "validateUser"}) RETURN caller.name, caller.filePath ORDER BY caller.filePath @@ -88,12 +96,12 @@ RETURN caller.name, caller.filePath ORDER BY caller.filePath ## Risk Rules -| Risk Factor | Mitigation | -|-------------|------------| -| Many callers (>5) | Use gitnexus_rename for automated updates | -| Cross-area refs | Use detect_changes after to verify scope | -| String/dynamic refs | gitnexus_query to find them | -| External/public API | Version and deprecate properly | +| Risk Factor | Mitigation | +| ------------------- | ----------------------------------------- | +| Many callers (>5) | Use gitnexus_rename for automated updates | +| Cross-area refs | Use detect_changes after to verify scope | +| String/dynamic refs | gitnexus_query to find them | +| External/public API | Version and deprecate properly | ## Example: Rename `validateUser` to `authenticateUser` diff --git a/gitnexus/src/cli/ai-context.ts b/gitnexus/src/cli/ai-context.ts index c3bf375af2..2ef720aa33 100644 --- a/gitnexus/src/cli/ai-context.ts +++ b/gitnexus/src/cli/ai-context.ts @@ -9,6 +9,7 @@ import fs from 'fs/promises'; import path from 'path'; import { fileURLToPath } from 'url'; +import { type GeneratedSkillInfo } from './skill-gen.js'; // ESM equivalent of __dirname const __filename = fileURLToPath(import.meta.url); @@ -28,76 +29,124 @@ const GITNEXUS_END_MARKER = '<!-- gitnexus:end -->'; /** * Generate the full GitNexus context content. - * - * Design principles (learned from real agent behavior): - * - AGENTS.md is the ROUTER — it tells the agent WHICH skill to read - * - Skills contain the actual workflows — AGENTS.md does NOT duplicate them - * - Bold **IMPORTANT** block + "Skills — Read First" heading — agents skip soft suggestions - * - One-line quick start (read context resource) gives agents an entry point - * - Tools/Resources sections are labeled "Reference" — agents treat them as lookup, not workflow + * + * Design principles (learned from real agent behavior and industry research): + * - Inline critical workflows — skills are skipped 56% of the time (Vercel eval data) + * - Use RFC 2119 language (MUST, NEVER, ALWAYS) — models follow imperative rules + * - Three-tier boundaries (Always/When/Never) — proven to change model behavior + * - Keep under 120 lines — adherence degrades past 150 lines + * - Exact tool commands with parameters — vague directives get ignored + * - Self-review checklist — forces model to verify its own work */ -function generateGitNexusContent(projectName: string, stats: RepoStats): string { - return `${GITNEXUS_START_MARKER} -# GitNexus MCP +function generateGitNexusContent(projectName: string, stats: RepoStats, generatedSkills?: GeneratedSkillInfo[]): string { + const generatedRows = (generatedSkills && generatedSkills.length > 0) + ? generatedSkills.map(s => + `| Work in the ${s.label} area (${s.symbolCount} symbols) | \`.claude/skills/generated/${s.name}/SKILL.md\` |` + ).join('\n') + : ''; -This project is indexed by GitNexus as **${projectName}** (${stats.nodes || 0} symbols, ${stats.edges || 0} relationships, ${stats.processes || 0} execution flows). - -GitNexus provides a knowledge graph over this codebase — call chains, blast radius, execution flows, and semantic search. - -## Always Start Here - -For any task involving code understanding, debugging, impact analysis, or refactoring, you must: - -1. **Read \`gitnexus://repo/{name}/context\`** — codebase overview + check index freshness -2. **Match your task to a skill below** and **read that skill file** -3. **Follow the skill's workflow and checklist** - -> If step 1 warns the index is stale, run \`npx gitnexus analyze\` in the terminal first. - -## Skills - -| Task | Read this skill file | + const skillsTable = `| Task | Read this skill file | |------|---------------------| -| Understand architecture / "How does X work?" | \`.claude/skills/gitnexus/exploring/SKILL.md\` | -| Blast radius / "What breaks if I change X?" | \`.claude/skills/gitnexus/impact-analysis/SKILL.md\` | -| Trace bugs / "Why is X failing?" | \`.claude/skills/gitnexus/debugging/SKILL.md\` | -| Rename / extract / split / refactor | \`.claude/skills/gitnexus/refactoring/SKILL.md\` | +| Understand architecture / "How does X work?" | \`.claude/skills/gitnexus/gitnexus-exploring/SKILL.md\` | +| Blast radius / "What breaks if I change X?" | \`.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md\` | +| Trace bugs / "Why is X failing?" | \`.claude/skills/gitnexus/gitnexus-debugging/SKILL.md\` | +| Rename / extract / split / refactor | \`.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md\` | +| Tools, resources, schema reference | \`.claude/skills/gitnexus/gitnexus-guide/SKILL.md\` | +| Index, status, clean, wiki CLI commands | \`.claude/skills/gitnexus/gitnexus-cli/SKILL.md\` |${generatedRows ? '\n' + generatedRows : ''}`; -## Tools Reference + return `${GITNEXUS_START_MARKER} +# GitNexus — Code Intelligence -| Tool | What it gives you | -|------|-------------------| -| \`query\` | Process-grouped code intelligence — execution flows related to a concept | -| \`context\` | 360-degree symbol view — categorized refs, processes it participates in | -| \`impact\` | Symbol blast radius — what breaks at depth 1/2/3 with confidence | -| \`detect_changes\` | Git-diff impact — what do your current changes affect | -| \`rename\` | Multi-file coordinated rename with confidence-tagged edits | -| \`cypher\` | Raw graph queries (read \`gitnexus://repo/{name}/schema\` first) | -| \`list_repos\` | Discover indexed repos | +This project is indexed by GitNexus as **${projectName}** (${stats.nodes || 0} symbols, ${stats.edges || 0} relationships, ${stats.processes || 0} execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely. -## Resources Reference +> If any GitNexus tool warns the index is stale, run \`npx gitnexus analyze\` in terminal first. -Lightweight reads (~100-500 tokens) for navigation: +## Always Do -| Resource | Content | +- **MUST run impact analysis before editing any symbol.** Before modifying a function, class, or method, run \`gitnexus_impact({target: "symbolName", direction: "upstream"})\` and report the blast radius (direct callers, affected processes, risk level) to the user. +- **MUST run \`gitnexus_detect_changes()\` before committing** to verify your changes only affect expected symbols and execution flows. +- **MUST warn the user** if impact analysis returns HIGH or CRITICAL risk before proceeding with edits. +- When exploring unfamiliar code, use \`gitnexus_query({query: "concept"})\` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance. +- When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use \`gitnexus_context({name: "symbolName"})\`. + +## When Debugging + +1. \`gitnexus_query({query: "<error or symptom>"})\` — find execution flows related to the issue +2. \`gitnexus_context({name: "<suspect function>"})\` — see all callers, callees, and process participation +3. \`READ gitnexus://repo/${projectName}/process/{processName}\` — trace the full execution flow step by step +4. For regressions: \`gitnexus_detect_changes({scope: "compare", base_ref: "main"})\` — see what your branch changed + +## When Refactoring + +- **Renaming**: MUST use \`gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})\` first. Review the preview — graph edits are safe, text_search edits need manual review. Then run with \`dry_run: false\`. +- **Extracting/Splitting**: MUST run \`gitnexus_context({name: "target"})\` to see all incoming/outgoing refs, then \`gitnexus_impact({target: "target", direction: "upstream"})\` to find all external callers before moving code. +- After any refactor: run \`gitnexus_detect_changes({scope: "all"})\` to verify only expected files changed. + +## Never Do + +- NEVER edit a function, class, or method without first running \`gitnexus_impact\` on it. +- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis. +- NEVER rename symbols with find-and-replace — use \`gitnexus_rename\` which understands the call graph. +- NEVER commit changes without running \`gitnexus_detect_changes()\` to check affected scope. + +## Tools Quick Reference + +| Tool | When to use | Command | +|------|-------------|---------| +| \`query\` | Find code by concept | \`gitnexus_query({query: "auth validation"})\` | +| \`context\` | 360-degree view of one symbol | \`gitnexus_context({name: "validateUser"})\` | +| \`impact\` | Blast radius before editing | \`gitnexus_impact({target: "X", direction: "upstream"})\` | +| \`detect_changes\` | Pre-commit scope check | \`gitnexus_detect_changes({scope: "staged"})\` | +| \`rename\` | Safe multi-file rename | \`gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})\` | +| \`cypher\` | Custom graph queries | \`gitnexus_cypher({query: "MATCH ..."})\` | + +## Impact Risk Levels + +| Depth | Meaning | Action | +|-------|---------|--------| +| d=1 | WILL BREAK — direct callers/importers | MUST update these | +| d=2 | LIKELY AFFECTED — indirect deps | Should test | +| d=3 | MAY NEED TESTING — transitive | Test if critical path | + +## Resources + +| Resource | Use for | |----------|---------| -| \`gitnexus://repo/{name}/context\` | Stats, staleness check | -| \`gitnexus://repo/{name}/clusters\` | All functional areas with cohesion scores | -| \`gitnexus://repo/{name}/cluster/{clusterName}\` | Area members | -| \`gitnexus://repo/{name}/processes\` | All execution flows | -| \`gitnexus://repo/{name}/process/{processName}\` | Step-by-step trace | -| \`gitnexus://repo/{name}/schema\` | Graph schema for Cypher | +| \`gitnexus://repo/${projectName}/context\` | Codebase overview, check index freshness | +| \`gitnexus://repo/${projectName}/clusters\` | All functional areas | +| \`gitnexus://repo/${projectName}/processes\` | All execution flows | +| \`gitnexus://repo/${projectName}/process/{name}\` | Step-by-step execution trace | -## Graph Schema +## Self-Check Before Finishing -**Nodes:** File, Function, Class, Interface, Method, Community, Process -**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS +Before completing any code modification task, verify: +1. \`gitnexus_impact\` was run for all modified symbols +2. No HIGH/CRITICAL risk warnings were ignored +3. \`gitnexus_detect_changes()\` confirms changes match expected scope +4. All d=1 (WILL BREAK) dependents were updated -\`\`\`cypher -MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"}) -RETURN caller.name, caller.filePath +## Keeping the Index Fresh + +After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it: + +\`\`\`bash +npx gitnexus analyze \`\`\` +If the index previously included embeddings, preserve them by adding \`--embeddings\`: + +\`\`\`bash +npx gitnexus analyze --embeddings +\`\`\` + +To check whether embeddings exist, inspect \`.gitnexus/meta.json\` — the \`stats.embeddings\` field shows the count (0 means no embeddings). **Running analyze without \`--embeddings\` will delete any previously generated embeddings.** + +> Claude Code users: A PostToolUse hook handles this automatically after \`git commit\` and \`git merge\`. + +## CLI + +${skillsTable} + ${GITNEXUS_END_MARKER}`; } @@ -137,7 +186,7 @@ async function upsertGitNexusSection( const startIdx = existingContent.indexOf(GITNEXUS_START_MARKER); const endIdx = existingContent.indexOf(GITNEXUS_END_MARKER); - if (startIdx !== -1 && endIdx !== -1) { + if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) { // Replace existing section const before = existingContent.substring(0, startIdx); const after = existingContent.substring(endIdx + GITNEXUS_END_MARKER.length); @@ -163,20 +212,28 @@ async function installSkills(repoPath: string): Promise<string[]> { // Skill definitions bundled with the package const skills = [ { - name: 'exploring', - description: 'Navigate unfamiliar code using GitNexus knowledge graph', + name: 'gitnexus-exploring', + description: 'Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: "How does X work?", "What calls this function?", "Show me the auth flow"', }, { - name: 'debugging', - description: 'Trace bugs through call chains using knowledge graph', + name: 'gitnexus-debugging', + description: 'Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: "Why is X failing?", "Where does this error come from?", "Trace this bug"', }, { - name: 'impact-analysis', - description: 'Analyze blast radius before making code changes', + name: 'gitnexus-impact-analysis', + description: 'Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: "Is it safe to change X?", "What depends on this?", "What will break?"', }, { - name: 'refactoring', - description: 'Plan safe refactors using blast radius and dependency mapping', + name: 'gitnexus-refactoring', + description: 'Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file"', + }, + { + name: 'gitnexus-guide', + description: 'Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: "What GitNexus tools are available?", "How do I use GitNexus?"', + }, + { + name: 'gitnexus-cli', + description: 'Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: "Index this repo", "Reanalyze the codebase", "Generate a wiki"', }, ]; @@ -197,7 +254,7 @@ async function installSkills(repoPath: string): Promise<string[]> { } catch { // Fallback: generate minimal skill content skillContent = `--- -name: gitnexus-${skill.name} +name: ${skill.name} description: ${skill.description} --- @@ -227,9 +284,10 @@ export async function generateAIContextFiles( repoPath: string, _storagePath: string, projectName: string, - stats: RepoStats + stats: RepoStats, + generatedSkills?: GeneratedSkillInfo[] ): Promise<{ files: string[] }> { - const content = generateGitNexusContent(projectName, stats); + const content = generateGitNexusContent(projectName, stats, generatedSkills); const createdFiles: string[] = []; // Create AGENTS.md (standard for Cursor, Windsurf, OpenCode, Cline, etc.) diff --git a/gitnexus/src/cli/analyze.ts b/gitnexus/src/cli/analyze.ts index a22a8dad58..4965563ead 100644 --- a/gitnexus/src/cli/analyze.ts +++ b/gitnexus/src/cli/analyze.ts @@ -5,20 +5,49 @@ */ import path from 'path'; +import { execFileSync } from 'child_process'; +import v8 from 'v8'; import cliProgress from 'cli-progress'; import { runPipelineFromRepo } from '../core/ingestion/pipeline.js'; -import { initKuzu, loadGraphToKuzu, getKuzuStats, executeQuery, executeWithReusedStatement, closeKuzu, createFTSIndex, loadCachedEmbeddings } from '../core/kuzu/kuzu-adapter.js'; -import { runEmbeddingPipeline } from '../core/embeddings/embedding-pipeline.js'; +import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings } from '../core/lbug/lbug-adapter.js'; +// Embedding imports are lazy (dynamic import) so onnxruntime-node is never +// loaded when embeddings are not requested. This avoids crashes on Node +// versions whose ABI is not yet supported by the native binary (#89). // disposeEmbedder intentionally not called — ONNX Runtime segfaults on cleanup (see #38) -import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath } from '../storage/repo-manager.js'; +import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath, cleanupOldKuzuFiles } from '../storage/repo-manager.js'; import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js'; import { generateAIContextFiles } from './ai-context.js'; +import { generateSkillFiles, type GeneratedSkillInfo } from './skill-gen.js'; import fs from 'fs/promises'; -import { registerClaudeHook } from './claude-hooks.js'; + + +const HEAP_MB = 8192; +const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`; + +/** Re-exec the process with an 8GB heap if we're currently below that. */ +function ensureHeap(): boolean { + const nodeOpts = process.env.NODE_OPTIONS || ''; + if (nodeOpts.includes('--max-old-space-size')) return false; + + const v8Heap = v8.getHeapStatistics().heap_size_limit; + if (v8Heap >= HEAP_MB * 1024 * 1024 * 0.9) return false; + + try { + execFileSync(process.execPath, [HEAP_FLAG, ...process.argv.slice(1)], { + stdio: 'inherit', + env: { ...process.env, NODE_OPTIONS: `${nodeOpts} ${HEAP_FLAG}`.trim() }, + }); + } catch (e: any) { + process.exitCode = e.status ?? 1; + } + return true; +} export interface AnalyzeOptions { force?: boolean; embeddings?: boolean; + skills?: boolean; + verbose?: boolean; } /** Threshold: auto-skip embeddings for repos with more nodes than this */ @@ -34,7 +63,7 @@ const PHASE_LABELS: Record<string, string> = { communities: 'Detecting communities', processes: 'Detecting processes', complete: 'Pipeline complete', - kuzu: 'Loading into KuzuDB', + lbug: 'Loading into LadybugDB', fts: 'Creating search indexes', embeddings: 'Generating embeddings', done: 'Done', @@ -44,6 +73,12 @@ export const analyzeCommand = async ( inputPath?: string, options?: AnalyzeOptions ) => { + if (ensureHeap()) return; + + if (options?.verbose) { + process.env.GITNEXUS_VERBOSE = '1'; + } + console.log('\n GitNexus Analyzer\n'); let repoPath: string; @@ -65,15 +100,27 @@ export const analyzeCommand = async ( return; } - const { storagePath, kuzuPath } = getStoragePaths(repoPath); + const { storagePath, lbugPath } = getStoragePaths(repoPath); + + // Clean up stale KuzuDB files from before the LadybugDB migration. + // If kuzu existed but lbug doesn't, we're doing a migration re-index — say so. + const kuzuResult = await cleanupOldKuzuFiles(storagePath); + if (kuzuResult.found && kuzuResult.needsReindex) { + console.log(' Migrating from KuzuDB to LadybugDB — rebuilding index...\n'); + } + const currentCommit = getCurrentCommit(repoPath); const existingMeta = await loadMeta(storagePath); - if (existingMeta && !options?.force && existingMeta.lastCommit === currentCommit) { + if (existingMeta && !options?.force && !options?.skills && existingMeta.lastCommit === currentCommit) { console.log(' Already up to date\n'); return; } + if (process.env.GITNEXUS_NO_GITIGNORE) { + console.log(' GITNEXUS_NO_GITIGNORE is set — skipping .gitignore (still reading .gitnexusignore)\n'); + } + // Single progress bar for entire pipeline const bar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {phase}', @@ -88,19 +135,47 @@ export const analyzeCommand = async ( bar.start(100, 0, { phase: 'Initializing...' }); + // Graceful SIGINT handling — clean up resources and exit + let aborted = false; + const sigintHandler = () => { + if (aborted) process.exit(1); // Second Ctrl-C: force exit + aborted = true; + bar.stop(); + console.log('\n Interrupted — cleaning up...'); + closeLbug().catch(() => {}).finally(() => process.exit(130)); + }; + process.on('SIGINT', sigintHandler); + // Route all console output through bar.log() so the bar doesn't stamp itself // multiple times when other code writes to stdout/stderr mid-render. const origLog = console.log.bind(console); const origWarn = console.warn.bind(console); const origError = console.error.bind(console); - const barLog = (...args: any[]) => origLog(args.map(a => (typeof a === 'string' ? a : String(a))).join(' ')); + const barLog = (...args: any[]) => { + // Clear the bar line, print the message, then let the next bar.update redraw + process.stdout.write('\x1b[2K\r'); + origLog(args.map(a => (typeof a === 'string' ? a : String(a))).join(' ')); + }; console.log = barLog; console.warn = barLog; console.error = barLog; - // Show elapsed seconds for phases that run longer than 3s + // Track elapsed time per phase — both updateBar and the interval use the + // same format so they don't flicker against each other. let lastPhaseLabel = 'Initializing...'; let phaseStart = Date.now(); + + /** Update bar with phase label + elapsed seconds (shown after 3s). */ + const updateBar = (value: number, phaseLabel: string) => { + if (phaseLabel !== lastPhaseLabel) { lastPhaseLabel = phaseLabel; phaseStart = Date.now(); } + const elapsed = Math.round((Date.now() - phaseStart) / 1000); + const display = elapsed >= 3 ? `${phaseLabel} (${elapsed}s)` : phaseLabel; + bar.update(value, { phase: display }); + }; + + // Tick elapsed seconds for phases with infrequent progress callbacks + // (e.g. CSV streaming, FTS indexing). Uses the same display format as + // updateBar so there's no flickering. const elapsedTimer = setInterval(() => { const elapsed = Math.round((Date.now() - phaseStart) / 1000); if (elapsed >= 3) { @@ -116,14 +191,14 @@ export const analyzeCommand = async ( if (options?.embeddings && existingMeta && !options?.force) { try { - bar.update(0, { phase: 'Caching embeddings...' }); - await initKuzu(kuzuPath); + updateBar(0, 'Caching embeddings...'); + await initLbug(lbugPath); const cached = await loadCachedEmbeddings(); cachedEmbeddingNodeIds = cached.embeddingNodeIds; cachedEmbeddings = cached.embeddings; - await closeKuzu(); + await closeLbug(); } catch { - try { await closeKuzu(); } catch {} + try { await closeLbug(); } catch {} } } @@ -131,34 +206,31 @@ export const analyzeCommand = async ( const pipelineResult = await runPipelineFromRepo(repoPath, (progress) => { const phaseLabel = PHASE_LABELS[progress.phase] || progress.phase; const scaled = Math.round(progress.percent * 0.6); - if (phaseLabel !== lastPhaseLabel) { lastPhaseLabel = phaseLabel; phaseStart = Date.now(); } - bar.update(scaled, { phase: phaseLabel }); + updateBar(scaled, phaseLabel); }); - // ── Phase 2: KuzuDB (60–85%) ────────────────────────────────────── - lastPhaseLabel = 'Loading into KuzuDB...'; phaseStart = Date.now(); - bar.update(60, { phase: lastPhaseLabel }); + // ── Phase 2: LadybugDB (60–85%) ────────────────────────────────────── + updateBar(60, 'Loading into LadybugDB...'); - await closeKuzu(); - const kuzuFiles = [kuzuPath, `${kuzuPath}.wal`, `${kuzuPath}.lock`]; - for (const f of kuzuFiles) { + await closeLbug(); + const lbugFiles = [lbugPath, `${lbugPath}.wal`, `${lbugPath}.lock`]; + for (const f of lbugFiles) { try { await fs.rm(f, { recursive: true, force: true }); } catch {} } - const t0Kuzu = Date.now(); - await initKuzu(kuzuPath); - let kuzuMsgCount = 0; - const kuzuResult = await loadGraphToKuzu(pipelineResult.graph, pipelineResult.fileContents, storagePath, (msg) => { - kuzuMsgCount++; - const progress = Math.min(84, 60 + Math.round((kuzuMsgCount / (kuzuMsgCount + 10)) * 24)); - bar.update(progress, { phase: msg }); + const t0Lbug = Date.now(); + await initLbug(lbugPath); + let lbugMsgCount = 0; + const lbugResult = await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => { + lbugMsgCount++; + const progress = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24)); + updateBar(progress, msg); }); - const kuzuTime = ((Date.now() - t0Kuzu) / 1000).toFixed(1); - const kuzuWarnings = kuzuResult.warnings; + const lbugTime = ((Date.now() - t0Lbug) / 1000).toFixed(1); + const lbugWarnings = lbugResult.warnings; // ── Phase 3: FTS (85–90%) ───────────────────────────────────────── - lastPhaseLabel = 'Creating search indexes...'; phaseStart = Date.now(); - bar.update(85, { phase: lastPhaseLabel }); + updateBar(85, 'Creating search indexes...'); const t0Fts = Date.now(); try { @@ -174,7 +246,7 @@ export const analyzeCommand = async ( // ── Phase 3.5: Re-insert cached embeddings ──────────────────────── if (cachedEmbeddings.length > 0) { - bar.update(88, { phase: `Restoring ${cachedEmbeddings.length} cached embeddings...` }); + updateBar(88, `Restoring ${cachedEmbeddings.length} cached embeddings...`); const EMBED_BATCH = 200; for (let i = 0; i < cachedEmbeddings.length; i += EMBED_BATCH) { const batch = cachedEmbeddings.slice(i, i + EMBED_BATCH); @@ -189,7 +261,7 @@ export const analyzeCommand = async ( } // ── Phase 4: Embeddings (90–98%) ────────────────────────────────── - const stats = await getKuzuStats(); + const stats = await getLbugStats(); let embeddingTime = '0.0'; let embeddingSkipped = true; let embeddingSkipReason = 'off (use --embeddings to enable)'; @@ -203,17 +275,16 @@ export const analyzeCommand = async ( } if (!embeddingSkipped) { - lastPhaseLabel = 'Loading embedding model...'; phaseStart = Date.now(); - bar.update(90, { phase: lastPhaseLabel }); + updateBar(90, 'Loading embedding model...'); const t0Emb = Date.now(); + const { runEmbeddingPipeline } = await import('../core/embeddings/embedding-pipeline.js'); await runEmbeddingPipeline( executeQuery, executeWithReusedStatement, (progress) => { const scaled = 90 + Math.round((progress.percent / 100) * 8); const label = progress.phase === 'loading-model' ? 'Loading embedding model...' : `Embedding ${progress.nodesProcessed || 0}/${progress.totalNodes || '?'}`; - if (label !== lastPhaseLabel) { lastPhaseLabel = label; phaseStart = Date.now(); } - bar.update(scaled, { phase: label }); + updateBar(scaled, label); }, {}, cachedEmbeddingNodeIds.size > 0 ? cachedEmbeddingNodeIds : undefined, @@ -222,26 +293,32 @@ export const analyzeCommand = async ( } // ── Phase 5: Finalize (98–100%) ─────────────────────────────────── - bar.update(98, { phase: 'Saving metadata...' }); + updateBar(98, 'Saving metadata...'); + + // Count embeddings in the index (cached + newly generated) + let embeddingCount = 0; + try { + const embResult = await executeQuery(`MATCH (e:CodeEmbedding) RETURN count(e) AS cnt`); + embeddingCount = embResult?.[0]?.cnt ?? 0; + } catch { /* table may not exist if embeddings never ran */ } const meta = { repoPath, lastCommit: currentCommit, indexedAt: new Date().toISOString(), stats: { - files: pipelineResult.fileContents.size, + files: pipelineResult.totalFileCount, nodes: stats.nodes, edges: stats.edges, communities: pipelineResult.communityResult?.stats.totalCommunities, processes: pipelineResult.processResult?.stats.totalProcesses, + embeddings: embeddingCount, }, }; await saveMeta(storagePath, meta); await registerRepo(repoPath, meta); await addToGitignore(repoPath); - const hookResult = await registerClaudeHook(); - const projectName = path.basename(repoPath); let aggregatedClusterCount = 0; if (pipelineResult.communityResult?.communities) { @@ -253,16 +330,23 @@ export const analyzeCommand = async ( aggregatedClusterCount = Array.from(groups.values()).filter(count => count >= 5).length; } + let generatedSkills: GeneratedSkillInfo[] = []; + if (options?.skills && pipelineResult.communityResult) { + updateBar(99, 'Generating skill files...'); + const skillResult = await generateSkillFiles(repoPath, projectName, pipelineResult); + generatedSkills = skillResult.skills; + } + const aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, { - files: pipelineResult.fileContents.size, + files: pipelineResult.totalFileCount, nodes: stats.nodes, edges: stats.edges, communities: pipelineResult.communityResult?.stats.totalCommunities, clusters: aggregatedClusterCount, processes: pipelineResult.processResult?.stats.totalProcesses, - }); + }, generatedSkills); - await closeKuzu(); + await closeLbug(); // Note: we intentionally do NOT call disposeEmbedder() here. // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs. // Since the process exits immediately after, Node.js reclaims everything. @@ -270,6 +354,8 @@ export const analyzeCommand = async ( const totalTime = ((Date.now() - t0Global) / 1000).toFixed(1); clearInterval(elapsedTimer); + process.removeListener('SIGINT', sigintHandler); + console.log = origLog; console.warn = origWarn; console.error = origError; @@ -281,23 +367,20 @@ export const analyzeCommand = async ( const embeddingsCached = cachedEmbeddings.length > 0; console.log(`\n Repository indexed successfully (${totalTime}s)${embeddingsCached ? ` [${cachedEmbeddings.length} embeddings cached]` : ''}\n`); console.log(` ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineResult.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineResult.processResult?.stats.totalProcesses || 0} flows`); - console.log(` KuzuDB ${kuzuTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`); + console.log(` LadybugDB ${lbugTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`); console.log(` ${repoPath}`); if (aiContext.files.length > 0) { console.log(` Context: ${aiContext.files.join(', ')}`); } - if (hookResult.registered) { - console.log(` Hooks: ${hookResult.message}`); - } - - // Show warnings (missing schema pairs, etc.) after the clean output - if (kuzuWarnings.length > 0) { - console.log(`\n Warnings (${kuzuWarnings.length}):`); - for (const w of kuzuWarnings) { - console.log(` ${w}`); - } + // Show a quiet summary if some edge types needed fallback insertion + if (lbugWarnings.length > 0) { + const totalFallback = lbugWarnings.reduce((sum, w) => { + const m = w.match(/\((\d+) edges\)/); + return sum + (m ? parseInt(m[1]) : 0); + }, 0); + console.log(` Note: ${totalFallback} edges across ${lbugWarnings.length} types inserted via fallback (schema will be updated in next release)`); } try { @@ -308,10 +391,8 @@ export const analyzeCommand = async ( console.log(''); - // ONNX Runtime registers native atexit hooks that segfault during process - // shutdown on macOS (#38) and some Linux configs (#40). Force-exit to - // bypass them when embeddings were loaded. - if (!embeddingSkipped) { - process.exit(0); - } + // LadybugDB's native module holds open handles that prevent Node from exiting. + // ONNX Runtime also registers native atexit hooks that segfault on some + // platforms (#38, #40). Force-exit to ensure clean termination. + process.exit(0); }; diff --git a/gitnexus/src/cli/augment.ts b/gitnexus/src/cli/augment.ts index b81d6feec8..3f758e0303 100644 --- a/gitnexus/src/cli/augment.ts +++ b/gitnexus/src/cli/augment.ts @@ -23,7 +23,7 @@ export async function augmentCommand(pattern: string): Promise<void> { if (result) { // IMPORTANT: Write to stderr, NOT stdout. - // KuzuDB's native module captures stdout fd at OS level during init, + // LadybugDB's native module captures stdout fd at OS level during init, // which makes stdout permanently broken in subprocess contexts. // stderr is never captured, so it works reliably everywhere. // The hook reads from the subprocess's stderr. diff --git a/gitnexus/src/cli/claude-hooks.ts b/gitnexus/src/cli/claude-hooks.ts deleted file mode 100644 index c81bcc752a..0000000000 --- a/gitnexus/src/cli/claude-hooks.ts +++ /dev/null @@ -1,111 +0,0 @@ -/** - * Claude Code Hook Registration - * - * Registers the GitNexus PreToolUse hook in ~/.claude/hooks.json - * so that grep/glob/bash calls are automatically augmented with - * knowledge graph context. - * - * Idempotent — safe to call multiple times. - */ - -import fs from 'fs/promises'; -import path from 'path'; -import os from 'os'; -import { fileURLToPath } from 'url'; - -const __filename = fileURLToPath(import.meta.url); -const __dirname = path.dirname(__filename); - -/** - * Get the absolute path to the gitnexus-hook.js file. - * Works for both local dev and npm-installed packages. - */ -function getHookScriptPath(): string { - // From dist/cli/claude-hooks.js → hooks/claude/gitnexus-hook.js - const packageRoot = path.resolve(__dirname, '..', '..'); - return path.join(packageRoot, 'hooks', 'claude', 'gitnexus-hook.cjs'); -} - -/** - * Register (or verify) the GitNexus hook in Claude Code's global hooks.json. - * - * - Creates ~/.claude/ and hooks.json if they don't exist - * - Preserves existing hooks from other tools - * - Skips if GitNexus hook is already registered - * - * Returns a status message for the CLI output. - */ -export async function registerClaudeHook(): Promise<{ registered: boolean; message: string }> { - const claudeDir = path.join(os.homedir(), '.claude'); - const hooksFile = path.join(claudeDir, 'hooks.json'); - const hookScript = getHookScriptPath(); - - // Check if the hook script exists - try { - await fs.access(hookScript); - } catch { - return { registered: false, message: 'Hook script not found (package may be incomplete)' }; - } - - // Build the hook command — use node + absolute path for reliability - const hookCommand = `node "${hookScript}"`; - - // Check if ~/.claude/ exists (user has Claude Code installed) - try { - await fs.access(claudeDir); - } catch { - // No Claude Code installation — skip silently - return { registered: false, message: 'Claude Code not detected (~/.claude/ not found)' }; - } - - // Read existing hooks.json or start fresh - let hooksConfig: any = {}; - try { - const existing = await fs.readFile(hooksFile, 'utf-8'); - hooksConfig = JSON.parse(existing); - } catch { - // File doesn't exist or is invalid — we'll create it - } - - // Ensure the hooks structure exists - if (!hooksConfig.hooks) { - hooksConfig.hooks = {}; - } - if (!Array.isArray(hooksConfig.hooks.PreToolUse)) { - hooksConfig.hooks.PreToolUse = []; - } - - // Check if GitNexus hook is already registered - const existingEntry = hooksConfig.hooks.PreToolUse.find((entry: any) => { - if (!entry.hooks || !Array.isArray(entry.hooks)) return false; - return entry.hooks.some((h: any) => - h.command && ( - h.command.includes('gitnexus-hook') || - h.command.includes('gitnexus augment') - ) - ); - }); - - if (existingEntry) { - return { registered: true, message: 'Claude Code hook already registered' }; - } - - // Add the GitNexus hook entry - hooksConfig.hooks.PreToolUse.push({ - matcher: { - tool_name: "Grep|Glob|Bash" - }, - hooks: [ - { - type: "command", - command: hookCommand, - timeout: 8000 - } - ] - }); - - // Write back - await fs.writeFile(hooksFile, JSON.stringify(hooksConfig, null, 2) + '\n', 'utf-8'); - - return { registered: true, message: 'Claude Code hook registered' }; -} diff --git a/gitnexus/src/cli/eval-server.ts b/gitnexus/src/cli/eval-server.ts index 49643dc5c1..35827eb91d 100644 --- a/gitnexus/src/cli/eval-server.ts +++ b/gitnexus/src/cli/eval-server.ts @@ -1,7 +1,7 @@ /** * Eval Server — Lightweight HTTP server for SWE-bench evaluation * - * Keeps KuzuDB warm in memory so tool calls from the agent are near-instant. + * Keeps LadybugDB warm in memory so tool calls from the agent are near-instant. * Designed to run inside Docker containers during SWE-bench evaluation. * * KEY DESIGN: Returns LLM-friendly text, not raw JSON. @@ -25,6 +25,7 @@ */ import http from 'http'; +import { writeSync } from 'node:fs'; import { LocalBackend } from '../mcp/local/local-backend.js'; export interface EvalServerOptions { @@ -36,7 +37,7 @@ export interface EvalServerOptions { // Convert structured JSON results into compact, LLM-friendly text. // Design: minimize tokens, maximize actionability. -function formatQueryResult(result: any): string { +export function formatQueryResult(result: any): string { if (result.error) return `Error: ${result.error}`; const lines: string[] = []; @@ -77,7 +78,7 @@ function formatQueryResult(result: any): string { return lines.join('\n').trim(); } -function formatContextResult(result: any): string { +export function formatContextResult(result: any): string { if (result.error) return `Error: ${result.error}`; if (result.status === 'ambiguous') { @@ -141,8 +142,11 @@ function formatContextResult(result: any): string { return lines.join('\n').trim(); } -function formatImpactResult(result: any): string { - if (result.error) return `Error: ${result.error}`; +export function formatImpactResult(result: any): string { + if (result.error) { + const suggestion = result.suggestion ? `\nSuggestion: ${result.suggestion}` : ''; + return `Error: ${result.error}${suggestion}`; + } const target = result.target; const direction = result.direction; @@ -155,7 +159,11 @@ function formatImpactResult(result: any): string { const lines: string[] = []; const dirLabel = direction === 'upstream' ? 'depends on this (will break if changed)' : 'this depends on'; - lines.push(`Blast radius for ${target?.kind || ''} ${target?.name} (${direction}): ${total} symbol(s) ${dirLabel}\n`); + lines.push(`Blast radius for ${target?.kind || ''} ${target?.name} (${direction}): ${total} symbol(s) ${dirLabel}`); + if (result.partial) { + lines.push('⚠️ Partial results — graph traversal was interrupted. Deeper impacts may exist.'); + } + lines.push(''); const depthLabels: Record<number, string> = { 1: 'WILL BREAK (direct)', @@ -181,7 +189,7 @@ function formatImpactResult(result: any): string { return lines.join('\n').trim(); } -function formatCypherResult(result: any): string { +export function formatCypherResult(result: any): string { if (result.error) return `Error: ${result.error}`; if (Array.isArray(result)) { @@ -202,7 +210,7 @@ function formatCypherResult(result: any): string { return typeof result === 'string' ? result : JSON.stringify(result, null, 2); } -function formatDetectChangesResult(result: any): string { +export function formatDetectChangesResult(result: any): string { if (result.error) return `Error: ${result.error}`; const summary = result.summary || {}; @@ -238,7 +246,7 @@ function formatDetectChangesResult(result: any): string { return lines.join('\n').trim(); } -function formatListReposResult(result: any): string { +export function formatListReposResult(result: any): string { if (!Array.isArray(result) || result.length === 0) { return 'No indexed repositories.'; } @@ -401,9 +409,10 @@ export async function evalServerCommand(options?: EvalServerOptions): Promise<vo console.error(` Auto-shutdown after ${idleTimeoutSec}s idle`); } try { - process.stdout.write(`GITNEXUS_EVAL_SERVER_READY:${port}\n`); + // Use fd 1 directly — LadybugDB captures process.stdout (#324) + writeSync(1, `GITNEXUS_EVAL_SERVER_READY:${port}\n`); } catch { - // stdout may not be available + // stdout may not be available (e.g., broken pipe) } }); @@ -420,10 +429,20 @@ export async function evalServerCommand(options?: EvalServerOptions): Promise<vo process.on('SIGTERM', shutdown); } +export const MAX_BODY_SIZE = 1024 * 1024; // 1MB + function readBody(req: http.IncomingMessage): Promise<string> { return new Promise((resolve, reject) => { const chunks: Buffer[] = []; - req.on('data', (chunk: Buffer) => chunks.push(chunk)); + let totalSize = 0; + req.on('data', (chunk: Buffer) => { + totalSize += chunk.length; + if (totalSize > MAX_BODY_SIZE) { + req.destroy(new Error('Request body too large (max 1MB)')); + return; + } + chunks.push(chunk); + }); req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8'))); req.on('error', reject); }); diff --git a/gitnexus/src/cli/index.ts b/gitnexus/src/cli/index.ts index fdcbb1f16d..6f5164f5c3 100644 --- a/gitnexus/src/cli/index.ts +++ b/gitnexus/src/cli/index.ts @@ -1,62 +1,65 @@ #!/usr/bin/env node + +// Heap re-spawn removed — only analyze.ts needs the 8GB heap (via its own ensureHeap()). +// Removing it from here improves MCP server startup time significantly. + import { Command } from 'commander'; -import { analyzeCommand } from './analyze.js'; -import { serveCommand } from './serve.js'; -import { listCommand } from './list.js'; -import { statusCommand } from './status.js'; -import { mcpCommand } from './mcp.js'; -import { cleanCommand } from './clean.js'; -import { setupCommand } from './setup.js'; -import { augmentCommand } from './augment.js'; -import { wikiCommand } from './wiki.js'; -import { queryCommand, contextCommand, impactCommand, cypherCommand } from './tool.js'; -import { evalServerCommand } from './eval-server.js'; +import { createRequire } from 'node:module'; +import { createLazyAction } from './lazy-action.js'; + +const _require = createRequire(import.meta.url); +const pkg = _require('../../package.json'); const program = new Command(); program .name('gitnexus') .description('GitNexus local CLI and MCP server') - .version('1.2.0'); + .version(pkg.version); program .command('setup') .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode, Codex') - .action(setupCommand); + .action(createLazyAction(() => import('./setup.js'), 'setupCommand')); + program .command('analyze [path]') .description('Index a repository (full analysis)') .option('-f, --force', 'Force full re-index even if up to date') .option('--embeddings', 'Enable embedding generation for semantic search (off by default)') - .action(analyzeCommand); + .option('--skills', 'Generate repo-specific skill files from detected communities') + .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)') + .addHelpText('after', '\nEnvironment variables:\n GITNEXUS_NO_GITIGNORE=1 Skip .gitignore parsing (still reads .gitnexusignore)') + .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand')); program .command('serve') .description('Start local HTTP server for web UI connection') .option('-p, --port <port>', 'Port number', '4747') - .action(serveCommand); + .option('--host <host>', 'Bind address (default: 127.0.0.1, use 0.0.0.0 for remote access)') + .action(createLazyAction(() => import('./serve.js'), 'serveCommand')); program .command('mcp') .description('Start MCP server (stdio) — serves all indexed repos') - .action(mcpCommand); + .action(createLazyAction(() => import('./mcp.js'), 'mcpCommand')); program .command('list') .description('List all indexed repositories') - .action(listCommand); + .action(createLazyAction(() => import('./list.js'), 'listCommand')); program .command('status') .description('Show index status for current repo') - .action(statusCommand); + .action(createLazyAction(() => import('./status.js'), 'statusCommand')); program .command('clean') .description('Delete GitNexus index for current repo') .option('-f, --force', 'Skip confirmation prompt') .option('--all', 'Clean all indexed repos') - .action(cleanCommand); + .action(createLazyAction(() => import('./clean.js'), 'cleanCommand')); program .command('wiki [path]') @@ -67,12 +70,12 @@ program .option('--api-key <key>', 'LLM API key (saved to ~/.gitnexus/config.json)') .option('--concurrency <n>', 'Parallel LLM calls (default: 3)', '3') .option('--gist', 'Publish wiki as a public GitHub Gist after generation') - .action(wikiCommand); + .action(createLazyAction(() => import('./wiki.js'), 'wikiCommand')); program .command('augment <pattern>') .description('Augment a search pattern with knowledge graph context (used by hooks)') - .action(augmentCommand); + .action(createLazyAction(() => import('./augment.js'), 'augmentCommand')); // ─── Direct Tool Commands (no MCP overhead) ──────────────────────── // These invoke LocalBackend directly for use in eval, scripts, and CI. @@ -85,7 +88,7 @@ program .option('-g, --goal <text>', 'What you want to find') .option('-l, --limit <n>', 'Max processes to return (default: 5)') .option('--content', 'Include full symbol source code') - .action(queryCommand); + .action(createLazyAction(() => import('./tool.js'), 'queryCommand')); program .command('context [name]') @@ -94,7 +97,7 @@ program .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)') .option('-f, --file <path>', 'File path to disambiguate common names') .option('--content', 'Include full symbol source code') - .action(contextCommand); + .action(createLazyAction(() => import('./tool.js'), 'contextCommand')); program .command('impact <target>') @@ -103,13 +106,13 @@ program .option('-r, --repo <name>', 'Target repository') .option('--depth <n>', 'Max relationship depth (default: 3)') .option('--include-tests', 'Include test files in results') - .action(impactCommand); + .action(createLazyAction(() => import('./tool.js'), 'impactCommand')); program .command('cypher <query>') .description('Execute raw Cypher query against the knowledge graph') .option('-r, --repo <name>', 'Target repository') - .action(cypherCommand); + .action(createLazyAction(() => import('./tool.js'), 'cypherCommand')); // ─── Eval Server (persistent daemon for SWE-bench) ───────────────── @@ -118,6 +121,6 @@ program .description('Start lightweight HTTP server for fast tool calls during evaluation') .option('-p, --port <port>', 'Port number', '4848') .option('--idle-timeout <seconds>', 'Auto-shutdown after N seconds idle (0 = disabled)', '0') - .action(evalServerCommand); + .action(createLazyAction(() => import('./eval-server.js'), 'evalServerCommand')); program.parse(process.argv); diff --git a/gitnexus/src/cli/lazy-action.ts b/gitnexus/src/cli/lazy-action.ts new file mode 100644 index 0000000000..d6c7189ed5 --- /dev/null +++ b/gitnexus/src/cli/lazy-action.ts @@ -0,0 +1,26 @@ +/** + * Creates a lazy-loaded CLI action that defers module import until invocation. + * The generic constraints ensure the export name is a valid key of the module + * at compile time — catching typos when used with concrete module imports. + */ + +function isCallable(value: unknown): value is (...args: unknown[]) => unknown { + return typeof value === 'function'; +} + +export function createLazyAction< + TModule extends Record<string, unknown>, + TKey extends string & keyof TModule, +>( + loader: () => Promise<TModule>, + exportName: TKey, +): (...args: unknown[]) => Promise<void> { + return async (...args: unknown[]): Promise<void> => { + const module = await loader(); + const action = module[exportName]; + if (!isCallable(action)) { + throw new Error(`Lazy action export not found: ${exportName}`); + } + await action(...args); + }; +} diff --git a/gitnexus/src/cli/mcp.ts b/gitnexus/src/cli/mcp.ts index 90c55b9bd7..bc09943c8f 100644 --- a/gitnexus/src/cli/mcp.ts +++ b/gitnexus/src/cli/mcp.ts @@ -8,46 +8,33 @@ import { startMCPServer } from '../mcp/server.js'; import { LocalBackend } from '../mcp/local/local-backend.js'; -import { listRegisteredRepos } from '../storage/repo-manager.js'; export const mcpCommand = async () => { // Prevent unhandled errors from crashing the MCP server process. - // KuzuDB lock conflicts and transient errors should degrade gracefully. + // LadybugDB lock conflicts and transient errors should degrade gracefully. process.on('uncaughtException', (err) => { console.error(`GitNexus MCP: uncaught exception — ${err.message}`); + // Process is in an undefined state after uncaughtException — exit after flushing + setTimeout(() => process.exit(1), 100); }); process.on('unhandledRejection', (reason) => { const msg = reason instanceof Error ? reason.message : String(reason); console.error(`GitNexus MCP: unhandled rejection — ${msg}`); }); - // Load all registered repos - const entries = await listRegisteredRepos({ validate: true }); - - if (entries.length === 0) { - console.error(''); - console.error(' GitNexus: No indexed repositories found.'); - console.error(''); - console.error(' To get started:'); - console.error(' 1. cd into a git repository'); - console.error(' 2. Run: gitnexus analyze'); - console.error(' 3. Restart your editor'); - console.error(''); - process.exit(1); - } - - // Initialize multi-repo backend from registry + // Initialize multi-repo backend from registry. + // The server starts even with 0 repos — tools call refreshRepos() lazily, + // so repos indexed after the server starts are discovered automatically. const backend = new LocalBackend(); - const ok = await backend.init(); + await backend.init(); - if (!ok) { - console.error('GitNexus: Failed to initialize backend from registry.'); - process.exit(1); + const repos = await backend.listRepos(); + if (repos.length === 0) { + console.error('GitNexus: No indexed repos yet. Run `gitnexus analyze` in a git repo — the server will pick it up automatically.'); + } else { + console.error(`GitNexus: MCP server starting with ${repos.length} repo(s): ${repos.map(r => r.name).join(', ')}`); } - const repoNames = (await backend.listRepos()).map(r => r.name); - console.error(`GitNexus: MCP server starting with ${repoNames.length} repo(s): ${repoNames.join(', ')}`); - - // Start MCP server (serves all repos) + // Start MCP server (serves all repos, discovers new ones lazily) await startMCPServer(backend); }; diff --git a/gitnexus/src/cli/serve.ts b/gitnexus/src/cli/serve.ts index 8cde8d6310..104251d121 100644 --- a/gitnexus/src/cli/serve.ts +++ b/gitnexus/src/cli/serve.ts @@ -1,7 +1,7 @@ import { createServer } from '../server/api.js'; -export const serveCommand = async (options?: { port?: string }) => { +export const serveCommand = async (options?: { port?: string; host?: string }) => { const port = Number(options?.port ?? 4747); - await createServer(port); + const host = options?.host ?? '127.0.0.1'; + await createServer(port, host); }; - diff --git a/gitnexus/src/cli/setup.ts b/gitnexus/src/cli/setup.ts index 16c6303f94..eb8149f07d 100644 --- a/gitnexus/src/cli/setup.ts +++ b/gitnexus/src/cli/setup.ts @@ -12,6 +12,7 @@ import os from 'os'; import { execFile } from 'child_process'; import { promisify } from 'util'; import { fileURLToPath } from 'url'; +import { glob } from 'glob'; import { getGlobalDir } from '../storage/repo-manager.js'; const __filename = fileURLToPath(import.meta.url); @@ -166,13 +167,23 @@ async function installClaudeCodeHooks(result: SetupResult): Promise<void> { const src = path.join(pluginHooksPath, 'gitnexus-hook.cjs'); const dest = path.join(destHooksDir, 'gitnexus-hook.cjs'); try { - const content = await fs.readFile(src, 'utf-8'); + let content = await fs.readFile(src, 'utf-8'); + // Inject resolved CLI path so the copied hook can find the CLI + // even when it's no longer inside the npm package tree + const resolvedCli = path.join(__dirname, '..', 'cli', 'index.js'); + const normalizedCli = path.resolve(resolvedCli).replace(/\\/g, '/'); + const jsonCli = JSON.stringify(normalizedCli); + content = content.replace( + "let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');", + `let cliPath = ${jsonCli};` + ); await fs.writeFile(dest, content, 'utf-8'); } catch { // Script not found in source — skip } - const hookCmd = `node "${path.join(destHooksDir, 'gitnexus-hook.cjs').replace(/\\/g, '/')}"`; + const hookPath = path.join(destHooksDir, 'gitnexus-hook.cjs').replace(/\\/g, '/'); + const hookCmd = `node "${hookPath.replace(/"/g, '\\"')}"`; // Merge hook config into ~/.claude/settings.json const existing = await readJsonFile(settingsPath) || {}; @@ -181,25 +192,31 @@ async function installClaudeCodeHooks(result: SetupResult): Promise<void> { // NOTE: SessionStart hooks are broken on Windows (Claude Code bug #23576). // Session context is delivered via CLAUDE.md / skills instead. - // Add PreToolUse hook if not already present - if (!existing.hooks.PreToolUse) existing.hooks.PreToolUse = []; - const hasPreToolHook = existing.hooks.PreToolUse.some( - (h: any) => h.hooks?.some((hh: any) => hh.command?.includes('gitnexus')) - ); - if (!hasPreToolHook) { - existing.hooks.PreToolUse.push({ - matcher: 'Grep|Glob|Bash', - hooks: [{ - type: 'command', - command: hookCmd, - timeout: 8000, - statusMessage: 'Enriching with GitNexus graph context...', - }], - }); + // Helper: add a hook entry if one with 'gitnexus-hook' isn't already registered + interface HookEntry { hooks?: Array<{ command?: string }> } + function ensureHookEntry( + eventName: string, + matcher: string, + timeout: number, + statusMessage: string, + ) { + if (!existing.hooks[eventName]) existing.hooks[eventName] = []; + const hasHook = existing.hooks[eventName].some( + (h: HookEntry) => h.hooks?.some(hh => hh.command?.includes('gitnexus-hook')) + ); + if (!hasHook) { + existing.hooks[eventName].push({ + matcher, + hooks: [{ type: 'command', command: hookCmd, timeout, statusMessage }], + }); + } } + ensureHookEntry('PreToolUse', 'Grep|Glob|Bash', 10, 'Enriching with GitNexus graph context...'); + ensureHookEntry('PostToolUse', 'Bash', 10, 'Checking GitNexus index freshness...'); + await writeJsonFile(settingsPath, existing); - result.configured.push('Claude Code hooks (PreToolUse)'); + result.configured.push('Claude Code hooks (PreToolUse, PostToolUse)'); } catch (err: any) { result.errors.push(`Claude Code hooks: ${err.message}`); } @@ -290,8 +307,6 @@ async function setupCodex(result: SetupResult): Promise<void> { // ─── Skill Installation ─────────────────────────────────────────── -const SKILL_NAMES = ['exploring', 'debugging', 'impact-analysis', 'refactoring']; - /** * Install GitNexus skills to a target directory. * Each skill is installed as {targetDir}/gitnexus-{skillName}/SKILL.md @@ -305,25 +320,38 @@ async function installSkillsTo(targetDir: string): Promise<string[]> { const installed: string[] = []; const skillsRoot = path.join(__dirname, '..', '..', 'skills'); - for (const skillName of SKILL_NAMES) { - const skillDir = path.join(targetDir, `gitnexus-${skillName}`); + let flatFiles: string[] = []; + let dirSkillFiles: string[] = []; + try { + [flatFiles, dirSkillFiles] = await Promise.all([ + glob('*.md', { cwd: skillsRoot }), + glob('*/SKILL.md', { cwd: skillsRoot }), + ]); + } catch { + return []; + } + + const skillSources = new Map<string, { isDirectory: boolean }>(); + + for (const relPath of dirSkillFiles) { + skillSources.set(path.dirname(relPath), { isDirectory: true }); + } + for (const relPath of flatFiles) { + const skillName = path.basename(relPath, '.md'); + if (!skillSources.has(skillName)) { + skillSources.set(skillName, { isDirectory: false }); + } + } + + for (const [skillName, source] of skillSources) { + const skillDir = path.join(targetDir, skillName); try { - // Try directory-based skill first (skills/{name}/SKILL.md) - const dirSource = path.join(skillsRoot, skillName); - const dirSkillFile = path.join(dirSource, 'SKILL.md'); - - let isDirectory = false; - try { - const stat = await fs.stat(dirSource); - isDirectory = stat.isDirectory(); - } catch { /* not a directory */ } - - if (isDirectory) { + if (source.isDirectory) { + const dirSource = path.join(skillsRoot, skillName); await copyDirRecursive(dirSource, skillDir); installed.push(skillName); } else { - // Fall back to flat file (skills/{name}.md) const flatSource = path.join(skillsRoot, `${skillName}.md`); const content = await fs.readFile(flatSource, 'utf-8'); await fs.mkdir(skillDir, { recursive: true }); diff --git a/gitnexus/src/cli/skill-gen.ts b/gitnexus/src/cli/skill-gen.ts new file mode 100644 index 0000000000..07dce23e00 --- /dev/null +++ b/gitnexus/src/cli/skill-gen.ts @@ -0,0 +1,712 @@ +/** + * Skill File Generator + * + * Generates repo-specific SKILL.md files from detected Leiden communities. + * Each significant community becomes a skill that describes a functional area + * of the codebase, including key files, entry points, execution flows, and + * cross-community connections. + */ + +import fs from 'fs/promises'; +import path from 'path'; +import { PipelineResult } from '../types/pipeline.js'; +import { CommunityNode, CommunityMembership } from '../core/ingestion/community-processor.js'; +import { ProcessNode } from '../core/ingestion/process-processor.js'; +import { GraphNode, KnowledgeGraph } from '../core/graph/types.js'; + +// ============================================================================ +// TYPES +// ============================================================================ + +export interface GeneratedSkillInfo { + name: string; + label: string; + symbolCount: number; + fileCount: number; +} + +interface AggregatedCommunity { + label: string; + rawIds: string[]; + symbolCount: number; + cohesion: number; +} + +interface MemberSymbol { + id: string; + name: string; + label: string; + filePath: string; + startLine: number; + isExported: boolean; +} + +interface FileInfo { + relativePath: string; + symbols: string[]; +} + +interface CrossConnection { + targetLabel: string; + count: number; +} + +// ============================================================================ +// MAIN EXPORT +// ============================================================================ + +/** + * @brief Generate repo-specific skill files from detected communities + * @param {string} repoPath - Absolute path to the repository root + * @param {string} projectName - Human-readable project name + * @param {PipelineResult} pipelineResult - In-memory pipeline data with communities, processes, graph + * @returns {Promise<{ skills: GeneratedSkillInfo[], outputPath: string }>} Generated skill metadata + */ +export const generateSkillFiles = async ( + repoPath: string, + projectName: string, + pipelineResult: PipelineResult +): Promise<{ skills: GeneratedSkillInfo[]; outputPath: string }> => { + const { communityResult, processResult, graph } = pipelineResult; + const outputDir = path.join(repoPath, '.claude', 'skills', 'generated'); + + if (!communityResult || !communityResult.memberships.length) { + console.log('\n Skills: no communities detected, skipping skill generation'); + return { skills: [], outputPath: outputDir }; + } + + console.log('\n Generating repo-specific skills...'); + + // Step 1: Build communities from memberships (not the filtered communities array). + // The community processor skips singletons from its communities array but memberships + // include ALL assignments. For repos with sparse CALLS edges, the communities array + // can be empty while memberships still has useful groupings. + const communities = communityResult.communities.length > 0 + ? communityResult.communities + : buildCommunitiesFromMemberships(communityResult.memberships, graph, repoPath); + + const aggregated = aggregateCommunities(communities); + + // Step 2: Filter to significant communities + // Keep communities with >= 3 symbols after aggregation. + const significant = aggregated + .filter(c => c.symbolCount >= 3) + .sort((a, b) => b.symbolCount - a.symbolCount) + .slice(0, 20); + + if (significant.length === 0) { + console.log('\n Skills: no significant communities found (all below 3-symbol threshold)'); + return { skills: [], outputPath: outputDir }; + } + + // Step 3: Build lookup maps + const membershipsByComm = buildMembershipMap(communityResult.memberships); + const nodeIdToCommunityLabel = buildNodeCommunityLabelMap( + communityResult.memberships, + communities + ); + + // Step 4: Clear and recreate output directory + try { + await fs.rm(outputDir, { recursive: true, force: true }); + } catch { /* may not exist */ } + await fs.mkdir(outputDir, { recursive: true }); + + // Step 5: Generate skill files + const skills: GeneratedSkillInfo[] = []; + const usedNames = new Set<string>(); + + for (const community of significant) { + // Gather member symbols + const members = gatherMembers(community.rawIds, membershipsByComm, graph); + if (members.length === 0) continue; + + // Gather file info + const files = gatherFiles(members, repoPath); + + // Gather entry points + const entryPoints = gatherEntryPoints(members); + + // Gather execution flows + const flows = gatherFlows(community.rawIds, processResult?.processes || []); + + // Gather cross-community connections + const connections = gatherCrossConnections( + community.rawIds, + community.label, + membershipsByComm, + nodeIdToCommunityLabel, + graph + ); + + // Generate kebab name + const kebabName = toKebabName(community.label, usedNames); + usedNames.add(kebabName); + + // Generate SKILL.md content + const content = renderSkillMarkdown( + community, + projectName, + members, + files, + entryPoints, + flows, + connections, + kebabName + ); + + // Write file + const skillDir = path.join(outputDir, kebabName); + await fs.mkdir(skillDir, { recursive: true }); + await fs.writeFile(path.join(skillDir, 'SKILL.md'), content, 'utf-8'); + + const info: GeneratedSkillInfo = { + name: kebabName, + label: community.label, + symbolCount: community.symbolCount, + fileCount: files.length, + }; + skills.push(info); + + console.log(` \u2713 ${community.label} (${community.symbolCount} symbols, ${files.length} files)`); + } + + console.log(`\n ${skills.length} skills generated \u2192 .claude/skills/generated/`); + + return { skills, outputPath: outputDir }; +}; + +// ============================================================================ +// FALLBACK COMMUNITY BUILDER +// ============================================================================ + +/** + * @brief Build CommunityNode-like objects from raw memberships when the community + * processor's communities array is empty (all singletons were filtered out) + * @param {CommunityMembership[]} memberships - All node-to-community assignments + * @param {KnowledgeGraph} graph - The knowledge graph for resolving node metadata + * @param {string} repoPath - Repository root for path normalization + * @returns {CommunityNode[]} Synthetic community nodes built from membership data + */ +const buildCommunitiesFromMemberships = ( + memberships: CommunityMembership[], + graph: KnowledgeGraph, + repoPath: string +): CommunityNode[] => { + // Group memberships by communityId + const groups = new Map<string, string[]>(); + for (const m of memberships) { + const arr = groups.get(m.communityId); + if (arr) { + arr.push(m.nodeId); + } else { + groups.set(m.communityId, [m.nodeId]); + } + } + + const communities: CommunityNode[] = []; + + for (const [commId, nodeIds] of groups) { + // Derive a heuristic label from the most common parent directory + const folderCounts = new Map<string, number>(); + for (const nodeId of nodeIds) { + const node = graph.getNode(nodeId); + if (!node?.properties.filePath) continue; + const normalized = node.properties.filePath.replace(/\\/g, '/'); + const parts = normalized.split('/').filter(Boolean); + if (parts.length >= 2) { + const folder = parts[parts.length - 2]; + if (!['src', 'lib', 'core', 'utils', 'common', 'shared', 'helpers'].includes(folder.toLowerCase())) { + folderCounts.set(folder, (folderCounts.get(folder) || 0) + 1); + } + } + } + + let bestFolder = ''; + let bestCount = 0; + for (const [folder, count] of folderCounts) { + if (count > bestCount) { + bestCount = count; + bestFolder = folder; + } + } + + const label = bestFolder + ? bestFolder.charAt(0).toUpperCase() + bestFolder.slice(1) + : `Cluster_${commId.replace('comm_', '')}`; + + // Compute cohesion as internal-edge ratio (matches backend calculateCohesion). + // For each member node, count edges that stay inside the community vs total. + const nodeSet = new Set(nodeIds); + let internalEdges = 0; + let totalEdges = 0; + graph.forEachRelationship(rel => { + if (nodeSet.has(rel.sourceId)) { + totalEdges++; + if (nodeSet.has(rel.targetId)) internalEdges++; + } + }); + const cohesion = totalEdges > 0 ? Math.min(1.0, internalEdges / totalEdges) : 1.0; + + communities.push({ + id: commId, + label, + heuristicLabel: label, + cohesion, + symbolCount: nodeIds.length, + }); + } + + return communities.sort((a, b) => b.symbolCount - a.symbolCount); +}; + +// ============================================================================ +// AGGREGATION +// ============================================================================ + +/** + * @brief Aggregate raw Leiden communities by heuristicLabel + * @param {CommunityNode[]} communities - Raw community nodes from Leiden detection + * @returns {AggregatedCommunity[]} Aggregated communities grouped by label + */ +const aggregateCommunities = (communities: CommunityNode[]): AggregatedCommunity[] => { + const groups = new Map<string, { + rawIds: string[]; + totalSymbols: number; + weightedCohesion: number; + }>(); + + for (const c of communities) { + const label = c.heuristicLabel || c.label || 'Unknown'; + const symbols = c.symbolCount || 0; + const cohesion = c.cohesion || 0; + const existing = groups.get(label); + + if (!existing) { + groups.set(label, { + rawIds: [c.id], + totalSymbols: symbols, + weightedCohesion: cohesion * symbols, + }); + } else { + existing.rawIds.push(c.id); + existing.totalSymbols += symbols; + existing.weightedCohesion += cohesion * symbols; + } + } + + return Array.from(groups.entries()).map(([label, g]) => ({ + label, + rawIds: g.rawIds, + symbolCount: g.totalSymbols, + cohesion: g.totalSymbols > 0 ? g.weightedCohesion / g.totalSymbols : 0, + })); +}; + +// ============================================================================ +// LOOKUP MAP BUILDERS +// ============================================================================ + +/** + * @brief Build a map from communityId to member nodeIds + * @param {CommunityMembership[]} memberships - All membership records + * @returns {Map<string, string[]>} Map of communityId -> nodeId[] + */ +const buildMembershipMap = (memberships: CommunityMembership[]): Map<string, string[]> => { + const map = new Map<string, string[]>(); + for (const m of memberships) { + const arr = map.get(m.communityId); + if (arr) { + arr.push(m.nodeId); + } else { + map.set(m.communityId, [m.nodeId]); + } + } + return map; +}; + +/** + * @brief Build a map from nodeId to aggregated community label + * @param {CommunityMembership[]} memberships - All membership records + * @param {CommunityNode[]} communities - Community nodes with labels + * @returns {Map<string, string>} Map of nodeId -> community label + */ +const buildNodeCommunityLabelMap = ( + memberships: CommunityMembership[], + communities: CommunityNode[] +): Map<string, string> => { + const commIdToLabel = new Map<string, string>(); + for (const c of communities) { + commIdToLabel.set(c.id, c.heuristicLabel || c.label || 'Unknown'); + } + + const map = new Map<string, string>(); + for (const m of memberships) { + const label = commIdToLabel.get(m.communityId); + if (label) { + map.set(m.nodeId, label); + } + } + return map; +}; + +// ============================================================================ +// DATA GATHERING +// ============================================================================ + +/** + * @brief Gather member symbols for an aggregated community + * @param {string[]} rawIds - Raw community IDs belonging to this aggregated community + * @param {Map<string, string[]>} membershipsByComm - communityId -> nodeIds + * @param {KnowledgeGraph} graph - The knowledge graph + * @returns {MemberSymbol[]} Array of member symbol information + */ +const gatherMembers = ( + rawIds: string[], + membershipsByComm: Map<string, string[]>, + graph: KnowledgeGraph +): MemberSymbol[] => { + const seen = new Set<string>(); + const members: MemberSymbol[] = []; + + for (const commId of rawIds) { + const nodeIds = membershipsByComm.get(commId) || []; + for (const nodeId of nodeIds) { + if (seen.has(nodeId)) continue; + seen.add(nodeId); + + const node = graph.getNode(nodeId); + if (!node) continue; + + members.push({ + id: node.id, + name: node.properties.name, + label: node.label, + filePath: node.properties.filePath || '', + startLine: node.properties.startLine || 0, + isExported: node.properties.isExported === true, + }); + } + } + + return members; +}; + +/** + * @brief Gather deduplicated file info with per-file symbol names + * @param {MemberSymbol[]} members - Member symbols + * @param {string} repoPath - Repository root for relative path computation + * @returns {FileInfo[]} Sorted by symbol count descending + */ +const gatherFiles = (members: MemberSymbol[], repoPath: string): FileInfo[] => { + const fileMap = new Map<string, string[]>(); + + for (const m of members) { + if (!m.filePath) continue; + const rel = toRelativePath(m.filePath, repoPath); + const arr = fileMap.get(rel); + if (arr) { + arr.push(m.name); + } else { + fileMap.set(rel, [m.name]); + } + } + + return Array.from(fileMap.entries()) + .map(([relativePath, symbols]) => ({ relativePath, symbols })) + .sort((a, b) => b.symbols.length - a.symbols.length); +}; + +/** + * @brief Gather exported entry points prioritized by type + * @param {MemberSymbol[]} members - Member symbols + * @returns {MemberSymbol[]} Exported symbols sorted by type priority + */ +const gatherEntryPoints = (members: MemberSymbol[]): MemberSymbol[] => { + const typePriority: Record<string, number> = { + Function: 0, + Class: 1, + Method: 2, + Interface: 3, + }; + + return members + .filter(m => m.isExported) + .sort((a, b) => { + const pa = typePriority[a.label] ?? 99; + const pb = typePriority[b.label] ?? 99; + return pa - pb; + }); +}; + +/** + * @brief Gather execution flows touching this community + * @param {string[]} rawIds - Raw community IDs for this aggregated community + * @param {ProcessNode[]} processes - All detected processes + * @returns {ProcessNode[]} Processes whose communities intersect rawIds, sorted by stepCount + */ +const gatherFlows = (rawIds: string[], processes: ProcessNode[]): ProcessNode[] => { + const rawIdSet = new Set(rawIds); + + return processes + .filter(proc => proc.communities.some(cid => rawIdSet.has(cid))) + .sort((a, b) => b.stepCount - a.stepCount); +}; + +/** + * @brief Gather cross-community call connections + * @param {string[]} rawIds - Raw community IDs for this aggregated community + * @param {string} ownLabel - This community's aggregated label + * @param {Map<string, string[]>} membershipsByComm - communityId -> nodeIds + * @param {Map<string, string>} nodeIdToCommunityLabel - nodeId -> community label + * @param {KnowledgeGraph} graph - The knowledge graph + * @returns {CrossConnection[]} Aggregated cross-community connections sorted by count + */ +const gatherCrossConnections = ( + rawIds: string[], + ownLabel: string, + membershipsByComm: Map<string, string[]>, + nodeIdToCommunityLabel: Map<string, string>, + graph: KnowledgeGraph +): CrossConnection[] => { + // Collect all node IDs in this aggregated community + const ownNodeIds = new Set<string>(); + for (const commId of rawIds) { + const nodeIds = membershipsByComm.get(commId) || []; + for (const nid of nodeIds) { + ownNodeIds.add(nid); + } + } + + // Count outgoing CALLS to nodes in different communities + const targetCounts = new Map<string, number>(); + + graph.forEachRelationship(rel => { + if (rel.type !== 'CALLS') return; + if (!ownNodeIds.has(rel.sourceId)) return; + if (ownNodeIds.has(rel.targetId)) return; // same community + + const targetLabel = nodeIdToCommunityLabel.get(rel.targetId); + if (!targetLabel || targetLabel === ownLabel) return; + + targetCounts.set(targetLabel, (targetCounts.get(targetLabel) || 0) + 1); + }); + + return Array.from(targetCounts.entries()) + .map(([targetLabel, count]) => ({ targetLabel, count })) + .sort((a, b) => b.count - a.count); +}; + +// ============================================================================ +// MARKDOWN RENDERING +// ============================================================================ + +/** + * @brief Render SKILL.md content for a single community + * @param {AggregatedCommunity} community - The aggregated community data + * @param {string} projectName - Project name for the description + * @param {MemberSymbol[]} members - All member symbols + * @param {FileInfo[]} files - File info with symbol names + * @param {MemberSymbol[]} entryPoints - Exported entry point symbols + * @param {ProcessNode[]} flows - Execution flows touching this community + * @param {CrossConnection[]} connections - Cross-community connections + * @param {string} kebabName - Kebab-case name for the skill + * @returns {string} Full SKILL.md content + */ +const renderSkillMarkdown = ( + community: AggregatedCommunity, + projectName: string, + members: MemberSymbol[], + files: FileInfo[], + entryPoints: MemberSymbol[], + flows: ProcessNode[], + connections: CrossConnection[], + kebabName: string +): string => { + const cohesionPct = Math.round(community.cohesion * 100); + + // Dominant directory: most common top-level directory + const dominantDir = getDominantDirectory(files); + + // Top symbol names for "When to Use" + const topNames = entryPoints.slice(0, 3).map(e => e.name); + if (topNames.length === 0) { + // Fallback to any members + topNames.push(...members.slice(0, 3).map(m => m.name)); + } + + const lines: string[] = []; + + // Frontmatter + lines.push('---'); + lines.push(`name: ${kebabName}`); + lines.push(`description: "Skill for the ${community.label} area of ${projectName}. ${community.symbolCount} symbols across ${files.length} files."`); + lines.push('---'); + lines.push(''); + + // Title + lines.push(`# ${community.label}`); + lines.push(''); + lines.push(`${community.symbolCount} symbols | ${files.length} files | Cohesion: ${cohesionPct}%`); + lines.push(''); + + // When to Use + lines.push('## When to Use'); + lines.push(''); + if (dominantDir) { + lines.push(`- Working with code in \`${dominantDir}/\``); + } + if (topNames.length > 0) { + lines.push(`- Understanding how ${topNames.join(', ')} work`); + } + lines.push(`- Modifying ${community.label.toLowerCase()}-related functionality`); + lines.push(''); + + // Key Files (top 10) + lines.push('## Key Files'); + lines.push(''); + lines.push('| File | Symbols |'); + lines.push('|------|---------|'); + for (const f of files.slice(0, 10)) { + const symbolList = f.symbols.slice(0, 5).join(', '); + const suffix = f.symbols.length > 5 ? ` (+${f.symbols.length - 5})` : ''; + lines.push(`| \`${f.relativePath}\` | ${symbolList}${suffix} |`); + } + lines.push(''); + + // Entry Points (top 5) + if (entryPoints.length > 0) { + lines.push('## Entry Points'); + lines.push(''); + lines.push('Start here when exploring this area:'); + lines.push(''); + for (const ep of entryPoints.slice(0, 5)) { + lines.push(`- **\`${ep.name}\`** (${ep.label}) \u2014 \`${ep.filePath}:${ep.startLine}\``); + } + lines.push(''); + } + + // Key Symbols (top 20, exported first, then by type) + lines.push('## Key Symbols'); + lines.push(''); + lines.push('| Symbol | Type | File | Line |'); + lines.push('|--------|------|------|------|'); + const sortedMembers = [...members].sort((a, b) => { + if (a.isExported !== b.isExported) return a.isExported ? -1 : 1; + return a.label.localeCompare(b.label); + }); + for (const m of sortedMembers.slice(0, 20)) { + lines.push(`| \`${m.name}\` | ${m.label} | \`${m.filePath}\` | ${m.startLine} |`); + } + lines.push(''); + + // Execution Flows + if (flows.length > 0) { + lines.push('## Execution Flows'); + lines.push(''); + lines.push('| Flow | Type | Steps |'); + lines.push('|------|------|-------|'); + for (const f of flows.slice(0, 10)) { + lines.push(`| \`${f.heuristicLabel}\` | ${f.processType} | ${f.stepCount} |`); + } + lines.push(''); + } + + // Connected Areas + if (connections.length > 0) { + lines.push('## Connected Areas'); + lines.push(''); + lines.push('| Area | Connections |'); + lines.push('|------|-------------|'); + for (const c of connections.slice(0, 8)) { + lines.push(`| ${c.targetLabel} | ${c.count} calls |`); + } + lines.push(''); + } + + // How to Explore + const firstEntry = entryPoints.length > 0 ? entryPoints[0].name : (members.length > 0 ? members[0].name : community.label); + lines.push('## How to Explore'); + lines.push(''); + lines.push(`1. \`gitnexus_context({name: "${firstEntry}"})\` \u2014 see callers and callees`); + lines.push(`2. \`gitnexus_query({query: "${community.label.toLowerCase()}"})\` \u2014 find related execution flows`); + lines.push('3. Read key files listed above for implementation details'); + lines.push(''); + + return lines.join('\n'); +}; + +// ============================================================================ +// UTILITY HELPERS +// ============================================================================ + +/** + * @brief Convert a community label to a kebab-case directory name + * @param {string} label - The community label + * @param {Set<string>} usedNames - Already-used names for collision detection + * @returns {string} Unique kebab-case name capped at 50 characters + */ +const toKebabName = (label: string, usedNames: Set<string>): string => { + let name = label + .toLowerCase() + .replace(/[^a-z0-9]+/g, '-') + .replace(/^-+|-+$/g, '') + .slice(0, 50); + + if (!name) name = 'skill'; + + let candidate = name; + let counter = 2; + while (usedNames.has(candidate)) { + candidate = `${name}-${counter}`; + counter++; + } + + return candidate; +}; + +/** + * @brief Convert an absolute or repo-relative file path to a clean relative path + * @param {string} filePath - The file path from the graph node + * @param {string} repoPath - Repository root path + * @returns {string} Relative path using forward slashes + */ +const toRelativePath = (filePath: string, repoPath: string): string => { + // Normalize to forward slashes for cross-platform consistency + const normalizedFile = filePath.replace(/\\/g, '/'); + const normalizedRepo = repoPath.replace(/\\/g, '/'); + + if (normalizedFile.startsWith(normalizedRepo)) { + return normalizedFile.slice(normalizedRepo.length).replace(/^\//, ''); + } + // Already relative or different root + return normalizedFile.replace(/^\//, ''); +}; + +/** + * @brief Find the dominant (most common) top-level directory across files + * @param {FileInfo[]} files - File info entries + * @returns {string | null} Most common directory or null + */ +const getDominantDirectory = (files: FileInfo[]): string | null => { + const dirCounts = new Map<string, number>(); + + for (const f of files) { + const parts = f.relativePath.split('/'); + if (parts.length >= 2) { + const dir = parts[0]; + dirCounts.set(dir, (dirCounts.get(dir) || 0) + f.symbols.length); + } + } + + let best: string | null = null; + let bestCount = 0; + for (const [dir, count] of dirCounts) { + if (count > bestCount) { + bestCount = count; + best = dir; + } + } + + return best; +}; diff --git a/gitnexus/src/cli/status.ts b/gitnexus/src/cli/status.ts index 314e6f0624..483c9e87cc 100644 --- a/gitnexus/src/cli/status.ts +++ b/gitnexus/src/cli/status.ts @@ -4,12 +4,12 @@ * Shows the indexing status of the current repository. */ -import { findRepo } from '../storage/repo-manager.js'; -import { getCurrentCommit, isGitRepo } from '../storage/git.js'; +import { findRepo, getStoragePaths, hasKuzuIndex } from '../storage/repo-manager.js'; +import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js'; export const statusCommand = async () => { const cwd = process.cwd(); - + if (!isGitRepo(cwd)) { console.log('Not a git repository.'); return; @@ -17,8 +17,16 @@ export const statusCommand = async () => { const repo = await findRepo(cwd); if (!repo) { - console.log('Repository not indexed.'); - console.log('Run: gitnexus analyze'); + // Check if there's a stale KuzuDB index that needs migration + const repoRoot = getGitRoot(cwd) ?? cwd; + const { storagePath } = getStoragePaths(repoRoot); + if (await hasKuzuIndex(storagePath)) { + console.log('Repository has a stale KuzuDB index from a previous version.'); + console.log('Run: gitnexus analyze (rebuilds the index with LadybugDB)'); + } else { + console.log('Repository not indexed.'); + console.log('Run: gitnexus analyze'); + } return; } diff --git a/gitnexus/src/cli/tool.ts b/gitnexus/src/cli/tool.ts index 41997d80b5..16dde3047e 100644 --- a/gitnexus/src/cli/tool.ts +++ b/gitnexus/src/cli/tool.ts @@ -10,10 +10,12 @@ * gitnexus impact --target "AuthService" --direction upstream * gitnexus cypher "MATCH (n:Function) RETURN n.name LIMIT 10" * - * Note: Output goes to stderr because KuzuDB's native module captures stdout - * at the OS level during init. This is consistent with augment.ts. + * Note: Output goes to stdout via fs.writeSync(fd 1), bypassing LadybugDB's + * native module which captures the Node.js process.stdout stream during init. + * See the output() function for details (#324). */ +import { writeSync } from 'node:fs'; import { LocalBackend } from '../mcp/local/local-backend.js'; let _backend: LocalBackend | null = null; @@ -29,10 +31,29 @@ async function getBackend(): Promise<LocalBackend> { return _backend; } +/** + * Write tool output to stdout using low-level fd write. + * + * LadybugDB's native module captures Node.js process.stdout during init, + * but the underlying OS file descriptor 1 (stdout) remains intact. + * By using fs.writeSync(1, ...) we bypass the Node.js stream layer + * and write directly to the real stdout fd (#324). + * + * Falls back to stderr if the fd write fails (e.g., broken pipe). + */ function output(data: any): void { const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2); - // stderr because KuzuDB captures stdout at OS level - process.stderr.write(text + '\n'); + try { + writeSync(1, text + '\n'); + } catch (err: any) { + if (err?.code === 'EPIPE') { + // Consumer closed the pipe (e.g., `gitnexus cypher ... | head -1`) + // Exit cleanly per Unix convention + process.exit(0); + } + // Fallback: stderr (previous behavior, works on all platforms) + process.stderr.write(text + '\n'); + } } export async function queryCommand(queryText: string, options?: { @@ -92,15 +113,27 @@ export async function impactCommand(target: string, options?: { process.exit(1); } - const backend = await getBackend(); - const result = await backend.callTool('impact', { - target, - direction: options?.direction || 'upstream', - maxDepth: options?.depth ? parseInt(options.depth) : undefined, - includeTests: options?.includeTests ?? false, - repo: options?.repo, - }); - output(result); + try { + const backend = await getBackend(); + const result = await backend.callTool('impact', { + target, + direction: options?.direction || 'upstream', + maxDepth: options?.depth ? parseInt(options.depth, 10) : undefined, + includeTests: options?.includeTests ?? false, + repo: options?.repo, + }); + output(result); + } catch (err: unknown) { + // Belt-and-suspenders: catch infrastructure failures (getBackend, callTool transport) + // The backend's impact() already returns structured errors for graph query failures + output({ + error: (err instanceof Error ? err.message : String(err)) || 'Impact analysis failed unexpectedly', + target: { name: target }, + direction: options?.direction || 'upstream', + suggestion: 'Try reducing --depth or using gitnexus context <symbol> as a fallback', + }); + process.exit(1); + } } export async function cypherCommand(query: string, options?: { diff --git a/gitnexus/src/cli/wiki.ts b/gitnexus/src/cli/wiki.ts index ac626fe809..4e41473a2a 100644 --- a/gitnexus/src/cli/wiki.ts +++ b/gitnexus/src/cli/wiki.ts @@ -7,7 +7,7 @@ import path from 'path'; import readline from 'readline'; -import { execSync } from 'child_process'; +import { execSync, execFileSync } from 'child_process'; import cliProgress from 'cli-progress'; import { getGitRoot, isGitRepo } from '../storage/git.js'; import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig } from '../storage/repo-manager.js'; @@ -101,7 +101,7 @@ export const wikiCommand = async ( } // ── Check for existing index ──────────────────────────────────────── - const { storagePath, kuzuPath } = getStoragePaths(repoPath); + const { storagePath, lbugPath } = getStoragePaths(repoPath); const meta = await loadMeta(storagePath); if (!meta) { @@ -247,7 +247,7 @@ export const wikiCommand = async ( const generator = new WikiGenerator( repoPath, storagePath, - kuzuPath, + lbugPath, llmConfig, wikiOptions, (phase, percent, detail) => { @@ -343,10 +343,11 @@ function hasGhCLI(): boolean { function publishGist(htmlPath: string): { url: string; rawUrl: string } | null { try { - const output = execSync( - `gh gist create "${htmlPath}" --desc "Repository Wiki — generated by GitNexus" --public`, - { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }, - ).trim(); + const output = execFileSync('gh', [ + 'gist', 'create', htmlPath, + '--desc', 'Repository Wiki — generated by GitNexus', + '--public', + ], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim(); // gh gist create prints the gist URL as the last line const lines = output.split('\n'); diff --git a/gitnexus/src/config/ignore-service.ts b/gitnexus/src/config/ignore-service.ts index affd83578f..844564e020 100644 --- a/gitnexus/src/config/ignore-service.ts +++ b/gitnexus/src/config/ignore-service.ts @@ -1,3 +1,8 @@ +import ignore, { type Ignore } from 'ignore'; +import fs from 'fs/promises'; +import nodePath from 'path'; +import type { Path } from 'path-scurry'; + const DEFAULT_IGNORE_LIST = new Set([ // Version Control '.git', @@ -186,6 +191,10 @@ const IGNORED_FILES = new Set([ +// NOTE: Negation patterns in .gitnexusignore (e.g. `!vendor/`) cannot override +// entries in DEFAULT_IGNORE_LIST — this is intentional. The hardcoded list protects +// against indexing directories that are almost never source code (node_modules, .git, etc.). +// Users who need to include such directories should remove them from the hardcoded list. export const shouldIgnorePath = (filePath: string): boolean => { const normalizedPath = filePath.replace(/\\/g, '/'); const parts = normalizedPath.split('/'); @@ -237,3 +246,86 @@ export const shouldIgnorePath = (filePath: string): boolean => { return false; } +/** Check if a directory name is in the hardcoded ignore list */ +export const isHardcodedIgnoredDirectory = (name: string): boolean => { + return DEFAULT_IGNORE_LIST.has(name); +}; + +/** + * Load .gitignore and .gitnexusignore rules from the repo root. + * Returns an `ignore` instance with all patterns, or null if no files found. + */ +export interface IgnoreOptions { + /** Skip .gitignore parsing, only read .gitnexusignore. Defaults to GITNEXUS_NO_GITIGNORE env var. */ + noGitignore?: boolean; +} + +export const loadIgnoreRules = async ( + repoPath: string, + options?: IgnoreOptions +): Promise<Ignore | null> => { + const ig = ignore(); + let hasRules = false; + + // Allow users to bypass .gitignore parsing (e.g. when .gitignore accidentally excludes source files) + const skipGitignore = options?.noGitignore ?? !!process.env.GITNEXUS_NO_GITIGNORE; + const filenames = skipGitignore + ? ['.gitnexusignore'] + : ['.gitignore', '.gitnexusignore']; + + for (const filename of filenames) { + try { + const content = await fs.readFile(nodePath.join(repoPath, filename), 'utf-8'); + ig.add(content); + hasRules = true; + } catch (err: unknown) { + const code = (err as NodeJS.ErrnoException).code; + if (code !== 'ENOENT') { + console.warn(` Warning: could not read ${filename}: ${(err as Error).message}`); + } + } + } + + return hasRules ? ig : null; +}; + +/** + * Create a glob-compatible ignore filter combining: + * - .gitignore / .gitnexusignore patterns (via `ignore` package) + * - Hardcoded DEFAULT_IGNORE_LIST, IGNORED_EXTENSIONS, IGNORED_FILES + * + * Returns an IgnoreLike object for glob's `ignore` option, + * enabling directory-level pruning during traversal. + */ +export const createIgnoreFilter = async (repoPath: string, options?: IgnoreOptions) => { + const ig = await loadIgnoreRules(repoPath, options); + + return { + ignored(p: Path): boolean { + // path-scurry's Path.relative() returns POSIX paths on all platforms, + // which is what the `ignore` package expects. No explicit normalization needed. + const rel = p.relative(); + if (!rel) return false; + // Check .gitignore / .gitnexusignore patterns + if (ig && ig.ignores(rel)) return true; + // Fall back to hardcoded rules + return shouldIgnorePath(rel); + }, + childrenIgnored(p: Path): boolean { + // Fast path: check directory name against hardcoded list. + // Note: dot-directories (.git, .vscode, etc.) are primarily excluded by + // glob's `dot: false` option in filesystem-walker.ts. This check is + // defense-in-depth — do not remove `dot: false` assuming this covers it. + if (DEFAULT_IGNORE_LIST.has(p.name)) return true; + // Check against .gitignore / .gitnexusignore patterns. + // Test both bare path and path with trailing slash to handle + // bare-name patterns (e.g. `local`) and dir-only patterns (e.g. `local/`). + if (ig) { + const rel = p.relative(); + if (rel && (ig.ignores(rel) || ig.ignores(rel + '/'))) return true; + } + return false; + }, + }; +}; + diff --git a/gitnexus/src/config/supported-languages.ts b/gitnexus/src/config/supported-languages.ts index 15df37c547..48562033aa 100644 --- a/gitnexus/src/config/supported-languages.ts +++ b/gitnexus/src/config/supported-languages.ts @@ -7,8 +7,9 @@ export enum SupportedLanguages { CPlusPlus = 'cpp', CSharp = 'csharp', Go = 'go', + Ruby = 'ruby', Rust = 'rust', - // PHP = 'php', - // Ruby = 'ruby', - // Swift = 'swift', + PHP = 'php', + Kotlin = 'kotlin', + Swift = 'swift', } \ No newline at end of file diff --git a/gitnexus/src/core/augmentation/engine.ts b/gitnexus/src/core/augmentation/engine.ts index 41ce54eb33..d970fb6b78 100644 --- a/gitnexus/src/core/augmentation/engine.ts +++ b/gitnexus/src/core/augmentation/engine.ts @@ -24,7 +24,7 @@ import { listRegisteredRepos } from '../../storage/repo-manager.js'; async function findRepoForCwd(cwd: string): Promise<{ name: string; storagePath: string; - kuzuPath: string; + lbugPath: string; } | null> { try { const entries = await listRegisteredRepos({ validate: true }); @@ -66,7 +66,7 @@ async function findRepoForCwd(cwd: string): Promise<{ return { name: bestMatch.name, storagePath: bestMatch.storagePath, - kuzuPath: path.join(bestMatch.storagePath, 'kuzu'), + lbugPath: path.join(bestMatch.storagePath, 'lbug'), }; } catch { return null; @@ -92,19 +92,19 @@ export async function augment(pattern: string, cwd?: string): Promise<string> { const repo = await findRepoForCwd(workDir); if (!repo) return ''; - // Lazy-load kuzu adapter (skip unnecessary init) - const { initKuzu, executeQuery, isKuzuReady } = await import('../../mcp/core/kuzu-adapter.js'); - const { searchFTSFromKuzu } = await import('../search/bm25-index.js'); - + // Lazy-load lbug adapter (skip unnecessary init) + const { initLbug, executeQuery, isLbugReady } = await import('../../mcp/core/lbug-adapter.js'); + const { searchFTSFromLbug } = await import('../search/bm25-index.js'); + const repoId = repo.name.toLowerCase(); - - // Init KuzuDB if not already - if (!isKuzuReady(repoId)) { - await initKuzu(repoId, repo.kuzuPath); + + // Init LadybugDB if not already + if (!isLbugReady(repoId)) { + await initLbug(repoId, repo.lbugPath); } - + // Step 1: BM25 search (fast, no embeddings) - const bm25Results = await searchFTSFromKuzu(pattern, 10, repoId); + const bm25Results = await searchFTSFromLbug(pattern, 10, repoId); if (bm25Results.length === 0) return ''; @@ -140,8 +140,90 @@ export async function augment(pattern: string, cwd?: string): Promise<string> { if (symbolMatches.length === 0) return ''; - // Step 3: For top matches, fetch callers/callees/processes - // Also get cluster cohesion internally for ranking + // Step 3: Batch-fetch callers/callees/processes/cohesion for top matches + // Uses batched WHERE n.id IN [...] queries instead of per-symbol queries + const uniqueSymbols = symbolMatches.slice(0, 5).filter((sym, i, arr) => + arr.findIndex(s => s.nodeId === sym.nodeId) === i + ); + + if (uniqueSymbols.length === 0) return ''; + + const idList = uniqueSymbols.map(s => `'${s.nodeId.replace(/'/g, "''")}'`).join(', '); + + // Batch fetch callers + const callersMap = new Map<string, string[]>(); + try { + const rows = await executeQuery(repoId, ` + MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n) + WHERE n.id IN [${idList}] + RETURN n.id AS targetId, caller.name AS name + LIMIT 15 + `); + for (const r of rows) { + const tid = r.targetId || r[0]; + const name = r.name || r[1]; + if (tid && name) { + if (!callersMap.has(tid)) callersMap.set(tid, []); + callersMap.get(tid)!.push(name); + } + } + } catch { /* skip */ } + + // Batch fetch callees + const calleesMap = new Map<string, string[]>(); + try { + const rows = await executeQuery(repoId, ` + MATCH (n)-[:CodeRelation {type: 'CALLS'}]->(callee) + WHERE n.id IN [${idList}] + RETURN n.id AS sourceId, callee.name AS name + LIMIT 15 + `); + for (const r of rows) { + const sid = r.sourceId || r[0]; + const name = r.name || r[1]; + if (sid && name) { + if (!calleesMap.has(sid)) calleesMap.set(sid, []); + calleesMap.get(sid)!.push(name); + } + } + } catch { /* skip */ } + + // Batch fetch processes + const processesMap = new Map<string, string[]>(); + try { + const rows = await executeQuery(repoId, ` + MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) + WHERE n.id IN [${idList}] + RETURN n.id AS nodeId, p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount + `); + for (const r of rows) { + const nid = r.nodeId || r[0]; + const label = r.label || r[1]; + const step = r.step || r[2]; + const stepCount = r.stepCount || r[3]; + if (nid && label) { + if (!processesMap.has(nid)) processesMap.set(nid, []); + processesMap.get(nid)!.push(`${label} (step ${step}/${stepCount})`); + } + } + } catch { /* skip */ } + + // Batch fetch cohesion + const cohesionMap = new Map<string, number>(); + try { + const rows = await executeQuery(repoId, ` + MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) + WHERE n.id IN [${idList}] + RETURN n.id AS nodeId, c.cohesion AS cohesion + `); + for (const r of rows) { + const nid = r.nodeId || r[0]; + const coh = r.cohesion ?? r[1] ?? 0; + if (nid) cohesionMap.set(nid, coh); + } + } catch { /* skip */ } + + // Assemble enriched results const enriched: Array<{ name: string; filePath: string; @@ -150,72 +232,15 @@ export async function augment(pattern: string, cwd?: string): Promise<string> { processes: string[]; cohesion: number; }> = []; - - const seen = new Set<string>(); - - for (const sym of symbolMatches.slice(0, 5)) { - if (seen.has(sym.nodeId)) continue; - seen.add(sym.nodeId); - - const escaped = sym.nodeId.replace(/'/g, "''"); - - // Callers - let callers: string[] = []; - try { - const rows = await executeQuery(repoId, ` - MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n {id: '${escaped}'}) - RETURN caller.name AS name - LIMIT 3 - `); - callers = rows.map((r: any) => r.name || r[0]).filter(Boolean); - } catch { /* skip */ } - - // Callees - let callees: string[] = []; - try { - const rows = await executeQuery(repoId, ` - MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'CALLS'}]->(callee) - RETURN callee.name AS name - LIMIT 3 - `); - callees = rows.map((r: any) => r.name || r[0]).filter(Boolean); - } catch { /* skip */ } - - // Processes - let processes: string[] = []; - try { - const rows = await executeQuery(repoId, ` - MATCH (n {id: '${escaped}'})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) - RETURN p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount - `); - processes = rows.map((r: any) => { - const label = r.label || r[0]; - const step = r.step || r[1]; - const stepCount = r.stepCount || r[2]; - return `${label} (step ${step}/${stepCount})`; - }).filter(Boolean); - } catch { /* skip */ } - - // Cluster cohesion (internal ranking signal) - let cohesion = 0; - try { - const rows = await executeQuery(repoId, ` - MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) - RETURN c.cohesion AS cohesion - LIMIT 1 - `); - if (rows.length > 0) { - cohesion = (rows[0].cohesion ?? rows[0][0]) || 0; - } - } catch { /* skip */ } - + + for (const sym of uniqueSymbols) { enriched.push({ name: sym.name, filePath: sym.filePath, - callers, - callees, - processes, - cohesion, + callers: (callersMap.get(sym.nodeId) || []).slice(0, 3), + callees: (calleesMap.get(sym.nodeId) || []).slice(0, 3), + processes: processesMap.get(sym.nodeId) || [], + cohesion: cohesionMap.get(sym.nodeId) || 0, }); } diff --git a/gitnexus/src/core/embeddings/embedder.ts b/gitnexus/src/core/embeddings/embedder.ts index 32948863c0..c3c0b5f880 100644 --- a/gitnexus/src/core/embeddings/embedder.ts +++ b/gitnexus/src/core/embeddings/embedder.ts @@ -15,8 +15,44 @@ if (!process.env.ORT_LOG_LEVEL) { } import { pipeline, env, type FeatureExtractionPipeline } from '@huggingface/transformers'; +import { existsSync } from 'fs'; +import { execFileSync } from 'child_process'; +import { join } from 'path'; import { DEFAULT_EMBEDDING_CONFIG, type EmbeddingConfig, type ModelProgress } from './types.js'; +/** + * Check whether CUDA libraries are actually available on this system. + * ONNX Runtime's native layer crashes (uncatchable) if we attempt CUDA + * without the required shared libraries, so we probe first. + * + * Checks the dynamic linker cache (ldconfig) which covers all architectures + * and install paths, then falls back to CUDA_PATH / LD_LIBRARY_PATH env vars. + */ +function isCudaAvailable(): boolean { + // Primary: query the dynamic linker cache — covers all architectures, + // distro layouts, and custom install paths registered with ldconfig + try { + const out = execFileSync('ldconfig', ['-p'], { timeout: 3000, encoding: 'utf-8' }); + if (out.includes('libcublasLt.so.12')) return true; + } catch { + // ldconfig not available (e.g. non-standard container) + } + + // Fallback: check CUDA_PATH and LD_LIBRARY_PATH for environments where + // ldconfig doesn't know about the CUDA install (conda, manual /opt/cuda, etc.) + for (const envVar of ['CUDA_PATH', 'LD_LIBRARY_PATH']) { + const val = process.env[envVar]; + if (!val) continue; + for (const dir of val.split(':').filter(Boolean)) { + if (existsSync(join(dir, 'lib64', 'libcublasLt.so.12')) || + existsSync(join(dir, 'lib', 'libcublasLt.so.12')) || + existsSync(join(dir, 'libcublasLt.so.12'))) return true; + } + } + + return false; +} + // Module-level state for singleton pattern let embedderInstance: FeatureExtractionPipeline | null = null; let isInitializing = false; @@ -62,8 +98,10 @@ export const initEmbedder = async ( const finalConfig = { ...DEFAULT_EMBEDDING_CONFIG, ...config }; // On Windows, use DirectML for GPU acceleration (via DirectX12) // CUDA is only available on Linux x64 with onnxruntime-node + // Probe for CUDA first — ONNX Runtime crashes (uncatchable native error) + // if we attempt CUDA without the required shared libraries const isWindows = process.platform === 'win32'; - const gpuDevice = isWindows ? 'dml' : 'cuda'; + const gpuDevice = isWindows ? 'dml' : (isCudaAvailable() ? 'cuda' : 'cpu'); let requestedDevice = forceDevice || (finalConfig.device === 'auto' ? gpuDevice : finalConfig.device); initPromise = (async () => { @@ -224,7 +262,7 @@ export const embedBatch = async (texts: string[]): Promise<Float32Array[]> => { }; /** - * Convert Float32Array to regular number array (for KuzuDB storage) + * Convert Float32Array to regular number array (for LadybugDB storage) */ export const embeddingToArray = (embedding: Float32Array): number[] => { return Array.from(embedding); diff --git a/gitnexus/src/core/embeddings/embedding-pipeline.ts b/gitnexus/src/core/embeddings/embedding-pipeline.ts index 0de1fea07e..5fbd5cd0bd 100644 --- a/gitnexus/src/core/embeddings/embedding-pipeline.ts +++ b/gitnexus/src/core/embeddings/embedding-pipeline.ts @@ -2,10 +2,10 @@ * Embedding Pipeline Module * * Orchestrates the background embedding process: - * 1. Query embeddable nodes from KuzuDB + * 1. Query embeddable nodes from LadybugDB * 2. Generate text representations * 3. Batch embed using transformers.js - * 4. Update KuzuDB with embeddings + * 4. Update LadybugDB with embeddings * 5. Create vector index for semantic search */ @@ -29,7 +29,7 @@ const isDev = process.env.NODE_ENV === 'development'; export type EmbeddingProgressCallback = (progress: EmbeddingProgress) => void; /** - * Query all embeddable nodes from KuzuDB + * Query all embeddable nodes from LadybugDB * Uses table-specific queries (File has different schema than code elements) */ const queryEmbeddableNodes = async ( @@ -104,9 +104,23 @@ const batchInsertEmbeddings = async ( * Create the vector index for semantic search * Now indexes the separate CodeEmbedding table */ +let vectorExtensionLoaded = false; + const createVectorIndex = async ( executeQuery: (cypher: string) => Promise<any[]> ): Promise<void> => { + // LadybugDB v0.15+ requires explicit VECTOR extension loading (once per session) + if (!vectorExtensionLoaded) { + try { + await executeQuery('INSTALL VECTOR'); + await executeQuery('LOAD EXTENSION VECTOR'); + vectorExtensionLoaded = true; + } catch { + // Extension may already be loaded — CREATE_VECTOR_INDEX will fail clearly if not + vectorExtensionLoaded = true; + } + } + const cypher = ` CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine') `; @@ -124,7 +138,7 @@ const createVectorIndex = async ( /** * Run the embedding pipeline * - * @param executeQuery - Function to execute Cypher queries against KuzuDB + * @param executeQuery - Function to execute Cypher queries against LadybugDB * @param executeWithReusedStatement - Function to execute with reused prepared statement * @param onProgress - Callback for progress updates * @param config - Optional configuration override @@ -219,7 +233,7 @@ export const runEmbeddingPipeline = async ( // Embed the batch const embeddings = await embedBatch(texts); - // Update KuzuDB with embeddings + // Update LadybugDB with embeddings const updates = batch.map((node, i) => ({ id: node.id, embedding: embeddingToArray(embeddings[i]), @@ -326,51 +340,64 @@ export const semanticSearch = async ( return []; } - // Get metadata for each result by querying each node table - const results: SemanticSearchResult[] = []; - + // Group results by label for batched metadata queries + const byLabel = new Map<string, Array<{ nodeId: string; distance: number }>>(); for (const embRow of embResults) { const nodeId = embRow.nodeId ?? embRow[0]; const distance = embRow.distance ?? embRow[1]; - - // Extract label from node ID (format: Label:path:name) const labelEndIdx = nodeId.indexOf(':'); const label = labelEndIdx > 0 ? nodeId.substring(0, labelEndIdx) : 'Unknown'; - - // Query the specific table for this node - // File nodes don't have startLine/endLine + if (!byLabel.has(label)) byLabel.set(label, []); + byLabel.get(label)!.push({ nodeId, distance }); + } + + // Batch-fetch metadata per label + const results: SemanticSearchResult[] = []; + + for (const [label, items] of byLabel) { + const idList = items.map(i => `'${i.nodeId.replace(/'/g, "''")}'`).join(', '); try { let nodeQuery: string; if (label === 'File') { nodeQuery = ` - MATCH (n:File {id: '${nodeId.replace(/'/g, "''")}'}) - RETURN n.name AS name, n.filePath AS filePath + MATCH (n:File) WHERE n.id IN [${idList}] + RETURN n.id AS id, n.name AS name, n.filePath AS filePath `; } else { nodeQuery = ` - MATCH (n:${label} {id: '${nodeId.replace(/'/g, "''")}'}) - RETURN n.name AS name, n.filePath AS filePath, + MATCH (n:${label}) WHERE n.id IN [${idList}] + RETURN n.id AS id, n.name AS name, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine `; } const nodeRows = await executeQuery(nodeQuery); - if (nodeRows.length > 0) { - const nodeRow = nodeRows[0]; - results.push({ - nodeId, - name: nodeRow.name ?? nodeRow[0] ?? '', - label, - filePath: nodeRow.filePath ?? nodeRow[1] ?? '', - distance, - startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[2]) : undefined, - endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[3]) : undefined, - }); + const rowMap = new Map<string, any>(); + for (const row of nodeRows) { + const id = row.id ?? row[0]; + rowMap.set(id, row); + } + for (const item of items) { + const nodeRow = rowMap.get(item.nodeId); + if (nodeRow) { + results.push({ + nodeId: item.nodeId, + name: nodeRow.name ?? nodeRow[1] ?? '', + label, + filePath: nodeRow.filePath ?? nodeRow[2] ?? '', + distance: item.distance, + startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[3]) : undefined, + endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[4]) : undefined, + }); + } } } catch { // Table might not exist, skip } } + // Re-sort by distance since batch queries may have mixed order + results.sort((a, b) => a.distance - b.distance); + return results; }; diff --git a/gitnexus/src/core/embeddings/types.ts b/gitnexus/src/core/embeddings/types.ts index f345725725..7978bf4c06 100644 --- a/gitnexus/src/core/embeddings/types.ts +++ b/gitnexus/src/core/embeddings/types.ts @@ -92,7 +92,7 @@ export interface SemanticSearchResult { } /** - * Node data for embedding (minimal structure from KuzuDB query) + * Node data for embedding (minimal structure from LadybugDB query) */ export interface EmbeddableNode { id: string; diff --git a/gitnexus/src/core/graph/graph.ts b/gitnexus/src/core/graph/graph.ts index 20643d8a2c..4658131ccb 100644 --- a/gitnexus/src/core/graph/graph.ts +++ b/gitnexus/src/core/graph/graph.ts @@ -51,11 +51,17 @@ export const createKnowledgeGraph = (): KnowledgeGraph => { get nodes(){ return Array.from(nodeMap.values()) }, - + get relationships(){ return Array.from(relationshipMap.values()) }, + iterNodes: () => nodeMap.values(), + iterRelationships: () => relationshipMap.values(), + forEachNode(fn: (node: GraphNode) => void) { nodeMap.forEach(fn); }, + forEachRelationship(fn: (rel: GraphRelationship) => void) { relationshipMap.forEach(fn); }, + getNode: (id: string) => nodeMap.get(id), + // O(1) count getters - avoid creating arrays just for length get nodeCount() { return nodeMap.size; diff --git a/gitnexus/src/core/graph/types.ts b/gitnexus/src/core/graph/types.ts index ee37d94ea4..60b3581950 100644 --- a/gitnexus/src/core/graph/types.ts +++ b/gitnexus/src/core/graph/types.ts @@ -15,16 +15,38 @@ export type NodeLabel = | 'Type' | 'CodeElement' | 'Community' - | 'Process'; + | 'Process' + // Multi-language node types + | 'Struct' + | 'Macro' + | 'Typedef' + | 'Union' + | 'Namespace' + | 'Trait' + | 'Impl' + | 'TypeAlias' + | 'Const' + | 'Static' + | 'Property' + | 'Record' + | 'Delegate' + | 'Annotation' + | 'Constructor' + | 'Template'; +import { SupportedLanguages } from '../../config/supported-languages.js'; + export type NodeProperties = { name: string, filePath: string, startLine?: number, endLine?: number, - language?: string, + language?: SupportedLanguages, isExported?: boolean, + // Optional AST-derived framework hint (e.g. @Controller, @GetMapping) + astFrameworkMultiplier?: number, + astFrameworkReason?: string, // Community-specific properties heuristicLabel?: string, cohesion?: number, @@ -41,19 +63,25 @@ export type NodeProperties = { // Entry point scoring (computed by process detection) entryPointScore?: number, entryPointReason?: string, + // Method signature (for MRO disambiguation) + parameterCount?: number, + returnType?: string, } -export type RelationshipType = - | 'CONTAINS' - | 'CALLS' - | 'INHERITS' - | 'OVERRIDES' +export type RelationshipType = + | 'CONTAINS' + | 'CALLS' + | 'INHERITS' + | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' + | 'HAS_METHOD' + | 'HAS_PROPERTY' + | 'ACCESSES' | 'MEMBER_OF' | 'STEP_IN_PROCESS' @@ -70,19 +98,30 @@ export interface GraphRelationship { type: RelationshipType, /** Confidence score 0-1 (1.0 = certain, lower = uncertain resolution) */ confidence: number, - /** Resolution reason: 'import-resolved', 'same-file', 'fuzzy-global', or empty for non-CALLS */ + /** Semantics are edge-type-dependent: CALLS uses resolution tier, ACCESSES uses 'read'/'write', OVERRIDES uses MRO reason */ reason: string, /** Step number for STEP_IN_PROCESS relationships (1-indexed) */ step?: number, } export interface KnowledgeGraph { + /** Returns a full array copy — prefer iterNodes() for iteration */ nodes: GraphNode[], + /** Returns a full array copy — prefer iterRelationships() for iteration */ relationships: GraphRelationship[], + /** Zero-copy iterator over nodes */ + iterNodes: () => IterableIterator<GraphNode>, + /** Zero-copy iterator over relationships */ + iterRelationships: () => IterableIterator<GraphRelationship>, + /** Zero-copy forEach — avoids iterator protocol overhead in hot loops */ + forEachNode: (fn: (node: GraphNode) => void) => void, + forEachRelationship: (fn: (rel: GraphRelationship) => void) => void, + /** Lookup a single node by id — O(1) */ + getNode: (id: string) => GraphNode | undefined, nodeCount: number, relationshipCount: number, addNode: (node: GraphNode) => void, addRelationship: (relationship: GraphRelationship) => void, removeNode: (nodeId: string) => boolean, removeNodesByFile: (filePath: string) => number, -} \ No newline at end of file +} diff --git a/gitnexus/src/core/ingestion/ast-cache.ts b/gitnexus/src/core/ingestion/ast-cache.ts index 0ae105120f..011b9df65d 100644 --- a/gitnexus/src/core/ingestion/ast-cache.ts +++ b/gitnexus/src/core/ingestion/ast-cache.ts @@ -10,10 +10,11 @@ export interface ASTCache { } export const createASTCache = (maxSize: number = 50): ASTCache => { + const effectiveMax = Math.max(maxSize, 1); // Initialize the cache with a 'dispose' handler // This is the magic: When an item is evicted (dropped), this runs automatically. const cache = new LRUCache<string, Parser.Tree>({ - max: maxSize, + max: effectiveMax, dispose: (tree) => { try { // NOTE: web-tree-sitter has tree.delete(); native tree-sitter trees are GC-managed. @@ -41,7 +42,7 @@ export const createASTCache = (maxSize: number = 50): ASTCache => { stats: () => ({ size: cache.size, - maxSize: maxSize + maxSize: effectiveMax }) }; }; diff --git a/gitnexus/src/core/ingestion/call-processor.ts b/gitnexus/src/core/ingestion/call-processor.ts index b3766df2b9..3f36ee65b6 100644 --- a/gitnexus/src/core/ingestion/call-processor.ts +++ b/gitnexus/src/core/ingestion/call-processor.ts @@ -1,42 +1,43 @@ import { KnowledgeGraph } from '../graph/types.js'; import { ASTCache } from './ast-cache.js'; -import { SymbolTable } from './symbol-table.js'; -import { ImportMap } from './import-processor.js'; +import type { SymbolDefinition } from './symbol-table.js'; import Parser from 'tree-sitter'; -import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js'; +import type { ResolutionContext } from './resolution-context.js'; +import { TIER_CONFIDENCE, type ResolutionTier } from './resolution-context.js'; +import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js'; import { LANGUAGE_QUERIES } from './tree-sitter-queries.js'; import { generateId } from '../../lib/utils.js'; -import { getLanguageFromFilename, yieldToEventLoop } from './utils.js'; -import type { ExtractedCall } from './workers/parse-worker.js'; +import { + getLanguageFromFilename, + isVerboseIngestionEnabled, + yieldToEventLoop, + FUNCTION_NODE_TYPES, + extractFunctionName, + isBuiltInOrNoise, + countCallArguments, + inferCallForm, + extractReceiverName, + extractReceiverNode, + findEnclosingClassId, + CALL_EXPRESSION_TYPES, + extractMixedChain, + type MixedChainStep, +} from './utils.js'; +import { buildTypeEnv } from './type-env.js'; +import type { ConstructorBinding } from './type-env.js'; +import { getTreeSitterBufferSize } from './constants.js'; +import type { ExtractedCall, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js'; +import { callRouters } from './call-routing.js'; +import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js'; -/** - * Node types that represent function/method definitions across languages. - * Used to find the enclosing function for a call site. - */ -const FUNCTION_NODE_TYPES = new Set([ - // TypeScript/JavaScript - 'function_declaration', - 'arrow_function', - 'function_expression', - 'method_definition', - 'generator_function_declaration', - // Python - 'function_definition', - // Common async variants - 'async_function_declaration', - 'async_arrow_function', - // Java - 'method_declaration', - 'constructor_declaration', - // C/C++ - // 'function_definition' already included above - // Go - // 'method_declaration' already included from Java - // C# - 'local_function_statement', - // Rust - 'function_item', - 'impl_item', // Methods inside impl blocks +// Stdlib methods that preserve the receiver's type identity. When TypeEnv already +// strips nullable wrappers (Option<User> → User), these chain steps are no-ops +// for type resolution — the current type passes through unchanged. +const TYPE_PRESERVING_METHODS = new Set([ + 'unwrap', 'expect', 'unwrap_or', 'unwrap_or_default', 'unwrap_or_else', // Rust Option/Result + 'clone', 'to_owned', 'as_ref', 'as_mut', 'borrow', 'borrow_mut', // Rust clone/borrow + 'get', // Kotlin/Java Optional.get() + 'orElseThrow', // Java Optional ]); /** @@ -46,128 +47,127 @@ const FUNCTION_NODE_TYPES = new Set([ const findEnclosingFunction = ( node: any, filePath: string, - symbolTable: SymbolTable + ctx: ResolutionContext ): string | null => { let current = node.parent; - + while (current) { if (FUNCTION_NODE_TYPES.has(current.type)) { - // Found enclosing function - try to get its name - let funcName: string | null = null; - let label = 'Function'; - - // Different node types have different name locations - if (current.type === 'function_declaration' || - current.type === 'function_definition' || - current.type === 'async_function_declaration' || - current.type === 'generator_function_declaration' || - current.type === 'function_item') { // Rust function - // Named function: function foo() {} - const nameNode = current.childForFieldName?.('name') || - current.children?.find((c: any) => c.type === 'identifier' || c.type === 'property_identifier'); - funcName = nameNode?.text; - } else if (current.type === 'impl_item') { - // Rust method inside impl block: wrapper around function_item or const_item - // We need to look inside for the function_item - const funcItem = current.children?.find((c: any) => c.type === 'function_item'); - if (funcItem) { - const nameNode = funcItem.childForFieldName?.('name') || - funcItem.children?.find((c: any) => c.type === 'identifier'); - funcName = nameNode?.text; - label = 'Method'; - } - } else if (current.type === 'method_definition') { - // Method: foo() {} inside class (JS/TS) - const nameNode = current.childForFieldName?.('name') || - current.children?.find((c: any) => c.type === 'property_identifier'); - funcName = nameNode?.text; - label = 'Method'; - } else if (current.type === 'method_declaration') { - // Java method: public void foo() {} - const nameNode = current.childForFieldName?.('name') || - current.children?.find((c: any) => c.type === 'identifier'); - funcName = nameNode?.text; - label = 'Method'; - } else if (current.type === 'constructor_declaration') { - // Java constructor: public ClassName() {} - const nameNode = current.childForFieldName?.('name') || - current.children?.find((c: any) => c.type === 'identifier'); - funcName = nameNode?.text; - label = 'Method'; // Treat constructors as methods for process detection - } else if (current.type === 'arrow_function' || current.type === 'function_expression') { - // Arrow/expression: const foo = () => {} - check parent variable declarator - const parent = current.parent; - if (parent?.type === 'variable_declarator') { - const nameNode = parent.childForFieldName?.('name') || - parent.children?.find((c: any) => c.type === 'identifier'); - funcName = nameNode?.text; - } - } - + const { funcName, label } = extractFunctionName(current); + if (funcName) { - // Look up the function in symbol table to get its node ID - // Try exact match first - const nodeId = symbolTable.lookupExact(filePath, funcName); - if (nodeId) return nodeId; - - // Try construct ID manually if lookup fails (common for non-exported internal functions) - // Format should match what parsing-processor generates: "Function:path/to/file:funcName" - // Check if we already have a node with this ID in the symbol table to be safe - const generatedId = generateId(label, `${filePath}:${funcName}`); - - // Ideally we should verify this ID exists, but strictly speaking if we are inside it, - // it SHOULD exist. Returning it is better than falling back to File. - return generatedId; + const resolved = ctx.resolve(funcName, filePath); + if (resolved?.tier === 'same-file' && resolved.candidates.length > 0) { + return resolved.candidates[0].nodeId; + } + + return generateId(label, `${filePath}:${funcName}`); } - - // Couldn't determine function name - try parent (might be nested) } current = current.parent; } - - return null; // Top-level call (not inside any function) + + return null; +}; + +/** + * Verify constructor bindings against SymbolTable and infer receiver types. + * Shared between sequential (processCalls) and worker (processCallsFromExtracted) paths. + */ +const verifyConstructorBindings = ( + bindings: readonly ConstructorBinding[], + filePath: string, + ctx: ResolutionContext, + graph?: KnowledgeGraph, +): Map<string, string> => { + const verified = new Map<string, string>(); + + for (const { scope, varName, calleeName, receiverClassName } of bindings) { + const tiered = ctx.resolve(calleeName, filePath); + const isClass = tiered?.candidates.some(def => def.type === 'Class') ?? false; + + if (isClass) { + verified.set(receiverKey(scope, varName), calleeName); + } else { + let callableDefs = tiered?.candidates.filter(d => + d.type === 'Function' || d.type === 'Method' + ); + + // When receiver class is known (e.g. $this->method() in PHP), narrow + // candidates to methods owned by that class to avoid false disambiguation failures. + if (callableDefs && callableDefs.length > 1 && receiverClassName) { + if (graph) { + // Worker path: use graph.getNode (fast, already in-memory) + const narrowed = callableDefs.filter(d => { + if (!d.ownerId) return false; + const owner = graph.getNode(d.ownerId); + return owner?.properties.name === receiverClassName; + }); + if (narrowed.length > 0) callableDefs = narrowed; + } else { + // Sequential path: use ctx.resolve (no graph available) + const classResolved = ctx.resolve(receiverClassName, filePath); + if (classResolved && classResolved.candidates.length > 0) { + const classNodeIds = new Set(classResolved.candidates.map(c => c.nodeId)); + const narrowed = callableDefs.filter(d => + d.ownerId && classNodeIds.has(d.ownerId) + ); + if (narrowed.length > 0) callableDefs = narrowed; + } + } + } + + if (callableDefs && callableDefs.length === 1 && callableDefs[0].returnType) { + const typeName = extractReturnTypeName(callableDefs[0].returnType); + if (typeName) { + verified.set(receiverKey(scope, varName), typeName); + } + } + } + } + + return verified; }; export const processCalls = async ( graph: KnowledgeGraph, files: { path: string; content: string }[], astCache: ASTCache, - symbolTable: SymbolTable, - importMap: ImportMap, - onProgress?: (current: number, total: number) => void -) => { + ctx: ResolutionContext, + onProgress?: (current: number, total: number) => void, +): Promise<ExtractedHeritage[]> => { const parser = await loadParser(); + const collectedHeritage: ExtractedHeritage[] = []; + const pendingWrites: { receiverTypeName: string; propertyName: string; filePath: string; srcId: string }[] = []; + const logSkipped = isVerboseIngestionEnabled(); + const skippedByLang = logSkipped ? new Map<string, number>() : null; for (let i = 0; i < files.length; i++) { const file = files[i]; onProgress?.(i + 1, files.length); if (i % 20 === 0) await yieldToEventLoop(); - // 1. Check language support first const language = getLanguageFromFilename(file.path); if (!language) continue; + if (!isLanguageAvailable(language)) { + if (skippedByLang) { + skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1); + } + continue; + } const queryStr = LANGUAGE_QUERIES[language]; if (!queryStr) continue; - // 2. ALWAYS load the language before querying (parser is stateful) await loadLanguage(language, file.path); - // 3. Get AST (Try Cache First) let tree = astCache.get(file.path); - let wasReparsed = false; - if (!tree) { - // Cache Miss: Re-parse - // Use larger bufferSize for files > 32KB try { - tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 }); + tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) }); } catch (parseError) { - // Skip files that can't be parsed continue; } - wasReparsed = true; - // Cache re-parsed tree so heritage phase gets hits astCache.set(file.path, tree); } @@ -182,12 +182,58 @@ export const processCalls = async ( continue; } - // 3. Process each call match + const lang = getLanguageFromFilename(file.path); + const typeEnv = lang ? buildTypeEnv(tree, lang, ctx.symbols) : null; + const callRouter = callRouters[language]; + + const verifiedReceivers = typeEnv && typeEnv.constructorBindings.length > 0 + ? verifyConstructorBindings(typeEnv.constructorBindings, file.path, ctx) + : new Map<string, string>(); + const receiverIndex = buildReceiverTypeIndex(verifiedReceivers); + + ctx.enableCache(file.path); + matches.forEach(match => { const captureMap: Record<string, any> = {}; match.captures.forEach(c => captureMap[c.name] = c.node); + // ── Write access: emit ACCESSES {reason: 'write'} for assignments to member fields ── + if (captureMap['assignment'] && captureMap['assignment.receiver'] && captureMap['assignment.property']) { + const receiverNode = captureMap['assignment.receiver']; + const propertyName: string = captureMap['assignment.property'].text; + // Resolve receiver type: simple identifier → TypeEnv lookup or class resolution + let receiverTypeName: string | undefined; + const receiverText = receiverNode.text; + if (receiverText && typeEnv) { + receiverTypeName = typeEnv.lookup(receiverText, captureMap['assignment']); + } + // Fall back to verified constructor bindings (mirrors CALLS resolution tier 2) + if (!receiverTypeName && receiverText && receiverIndex.size > 0) { + const enclosing = findEnclosingFunction(captureMap['assignment'], file.path, ctx); + const funcName = enclosing ? extractFuncNameFromSourceId(enclosing) : ''; + receiverTypeName = lookupReceiverType(receiverIndex, funcName, receiverText); + } + if (!receiverTypeName && receiverText) { + const resolved = ctx.resolve(receiverText, file.path); + if (resolved?.candidates.some(d => + d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface' + || d.type === 'Enum' || d.type === 'Record' || d.type === 'Impl', + )) { + receiverTypeName = receiverText; + } + } + if (receiverTypeName) { + const enclosing = findEnclosingFunction(captureMap['assignment'], file.path, ctx); + const srcId = enclosing || generateId('File', file.path); + // Defer resolution: Ruby attr_accessor properties are registered during + // this same loop, so cross-file lookups fail if the declaring file hasn't + // been processed yet. Collect now, resolve after all files are done. + pendingWrites.push({ receiverTypeName, propertyName, filePath: file.path, srcId }); + } + // Assignment-only capture (no @call sibling): skip the rest of this + // forEach iteration — this acts as a `continue` in the match loop. + if (!captureMap['call']) return; + } - // Only process @call captures if (!captureMap['call']) return; const nameNode = captureMap['call.name']; @@ -195,26 +241,132 @@ export const processCalls = async ( const calledName = nameNode.text; - // Skip common built-ins and noise + const routed = callRouter(calledName, captureMap['call']); + if (routed) { + switch (routed.kind) { + case 'skip': + case 'import': + return; + + case 'heritage': + for (const item of routed.items) { + collectedHeritage.push({ + filePath: file.path, + className: item.enclosingClass, + parentName: item.mixinName, + kind: item.heritageKind, + }); + } + return; + + case 'properties': { + const fileId = generateId('File', file.path); + const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path); + for (const item of routed.items) { + const nodeId = generateId('Property', `${file.path}:${item.propName}`); + graph.addNode({ + id: nodeId, + label: 'Property', + properties: { + name: item.propName, filePath: file.path, + startLine: item.startLine, endLine: item.endLine, + language, isExported: true, + description: item.accessorType, + }, + }); + ctx.symbols.add(file.path, item.propName, nodeId, 'Property', { + ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}), + ...(item.declaredType ? { declaredType: item.declaredType } : {}), + }); + const relId = generateId('DEFINES', `${fileId}->${nodeId}`); + graph.addRelationship({ + id: relId, sourceId: fileId, targetId: nodeId, + type: 'DEFINES', confidence: 1.0, reason: '', + }); + if (propEnclosingClassId) { + graph.addRelationship({ + id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`), + sourceId: propEnclosingClassId, targetId: nodeId, + type: 'HAS_PROPERTY', confidence: 1.0, reason: '', + }); + } + } + return; + } + + case 'call': + break; + } + } + if (isBuiltInOrNoise(calledName)) return; - // 4. Resolve the target using priority strategy (returns confidence) - const resolved = resolveCallTarget( + const callNode = captureMap['call']; + const callForm = inferCallForm(callNode, nameNode); + const receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined; + let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined; + // Fall back to verified constructor bindings for return type inference + if (!receiverTypeName && receiverName && receiverIndex.size > 0) { + const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx); + const funcName = enclosingFunc ? extractFuncNameFromSourceId(enclosingFunc) : ''; + receiverTypeName = lookupReceiverType(receiverIndex, funcName, receiverName); + } + // Fall back to class-as-receiver for static method calls (e.g. UserService.find_user()). + // When the receiver name is not a variable in TypeEnv but resolves to a Class/Struct/Interface + // through the standard tiered resolution, use it directly as the receiver type. + if (!receiverTypeName && receiverName && callForm === 'member') { + const typeResolved = ctx.resolve(receiverName, file.path); + if (typeResolved && typeResolved.candidates.some( + d => d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct' || d.type === 'Enum', + )) { + receiverTypeName = receiverName; + } + } + // Hoist sourceId so it's available for ACCESSES edge emission during chain walk. + const enclosingFuncId = findEnclosingFunction(callNode, file.path, ctx); + const sourceId = enclosingFuncId || generateId('File', file.path); + + // Fall back to mixed chain resolution when the receiver is a complex expression + // (field chain, call chain, or interleaved — e.g. user.address.city.save() or + // svc.getUser().address.save()). Handles all cases with a single unified walk. + if (callForm === 'member' && !receiverTypeName && !receiverName) { + const receiverNode = extractReceiverNode(nameNode); + if (receiverNode) { + const extracted = extractMixedChain(receiverNode); + if (extracted && extracted.chain.length > 0) { + let currentType = extracted.baseReceiverName && typeEnv + ? typeEnv.lookup(extracted.baseReceiverName, callNode) + : undefined; + if (!currentType && extracted.baseReceiverName && receiverIndex.size > 0) { + const funcName = enclosingFuncId ? extractFuncNameFromSourceId(enclosingFuncId) : ''; + currentType = lookupReceiverType(receiverIndex, funcName, extracted.baseReceiverName); + } + if (!currentType && extracted.baseReceiverName) { + const cr = ctx.resolve(extracted.baseReceiverName, file.path); + if (cr?.candidates.some(d => + d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct' || d.type === 'Enum', + )) { + currentType = extracted.baseReceiverName; + } + } + if (currentType) { + receiverTypeName = walkMixedChain( + extracted.chain, currentType, file.path, ctx, + makeAccessEmitter(graph, sourceId), + ); + } + } + } + } + + const resolved = resolveCallTarget({ calledName, - file.path, - symbolTable, - importMap - ); + argCount: countCallArguments(callNode), + callForm, + receiverTypeName, + }, file.path, ctx); if (!resolved) return; - - // 5. Find the enclosing function (caller) - const callNode = captureMap['call']; - const enclosingFuncId = findEnclosingFunction(callNode, file.path, symbolTable); - - // Use enclosing function as source, fallback to file for top-level calls - const sourceId = enclosingFuncId || generateId('File', file.path); - const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`); graph.addRelationship({ @@ -227,8 +379,34 @@ export const processCalls = async ( }); }); - // Tree is now owned by the LRU cache — no manual delete needed + ctx.clearCache(); } + + // ── Resolve deferred write-access edges ── + // All properties (including Ruby attr_accessor) are now registered. + for (const pw of pendingWrites) { + const fieldOwner = resolveFieldOwnership(pw.receiverTypeName, pw.propertyName, pw.filePath, ctx); + if (fieldOwner) { + graph.addRelationship({ + id: generateId('ACCESSES', `${pw.srcId}:${fieldOwner.nodeId}:write`), + sourceId: pw.srcId, + targetId: fieldOwner.nodeId, + type: 'ACCESSES', + confidence: 1.0, + reason: 'write', + }); + } + } + + if (skippedByLang && skippedByLang.size > 0) { + for (const [lang, count] of skippedByLang.entries()) { + console.warn( + `[ingestion] Skipped ${count} ${lang} file(s) in call processing — ${lang} parser not available.` + ); + } + } + + return collectedHeritage; }; /** @@ -236,143 +414,570 @@ export const processCalls = async ( */ interface ResolveResult { nodeId: string; - confidence: number; // 0-1: how sure are we? - reason: string; // 'import-resolved' | 'same-file' | 'fuzzy-global' + confidence: number; + reason: string; + returnType?: string; } +const CALLABLE_SYMBOL_TYPES = new Set([ + 'Function', + 'Method', + 'Constructor', + 'Macro', + 'Delegate', +]); + +const CONSTRUCTOR_TARGET_TYPES = new Set(['Constructor', 'Class', 'Struct', 'Record']); + +const filterCallableCandidates = ( + candidates: readonly SymbolDefinition[], + argCount?: number, + callForm?: 'free' | 'member' | 'constructor', +): SymbolDefinition[] => { + let kindFiltered: SymbolDefinition[]; + + if (callForm === 'constructor') { + const constructors = candidates.filter(c => c.type === 'Constructor'); + if (constructors.length > 0) { + kindFiltered = constructors; + } else { + const types = candidates.filter(c => CONSTRUCTOR_TARGET_TYPES.has(c.type)); + kindFiltered = types.length > 0 ? types : candidates.filter(c => CALLABLE_SYMBOL_TYPES.has(c.type)); + } + } else { + kindFiltered = candidates.filter(c => CALLABLE_SYMBOL_TYPES.has(c.type)); + } + + if (kindFiltered.length === 0) return []; + if (argCount === undefined) return kindFiltered; + + const hasParameterMetadata = kindFiltered.some(candidate => candidate.parameterCount !== undefined); + if (!hasParameterMetadata) return kindFiltered; + + return kindFiltered.filter(candidate => + candidate.parameterCount === undefined || candidate.parameterCount === argCount + ); +}; + +const toResolveResult = ( + definition: SymbolDefinition, + tier: ResolutionTier, +): ResolveResult => ({ + nodeId: definition.nodeId, + confidence: TIER_CONFIDENCE[tier], + reason: tier === 'same-file' ? 'same-file' : tier === 'import-scoped' ? 'import-resolved' : 'global', + returnType: definition.returnType, +}); + + /** * Resolve a function call to its target node ID using priority strategy: - * A. Check imported files first (highest confidence) - * B. Check local file definitions - * C. Fuzzy global search (lowest confidence) - * - * Returns confidence score so agents know what to trust. + * A. Narrow candidates by scope tier via ctx.resolve() + * B. Filter to callable symbol kinds (constructor-aware when callForm is set) + * C. Apply arity filtering when parameter metadata is available + * D. Apply receiver-type filtering for member calls with typed receivers + * + * If filtering still leaves multiple candidates, refuse to emit a CALLS edge. */ const resolveCallTarget = ( - calledName: string, + call: Pick<ExtractedCall, 'calledName' | 'argCount' | 'callForm' | 'receiverTypeName'>, currentFile: string, - symbolTable: SymbolTable, - importMap: ImportMap + ctx: ResolutionContext, ): ResolveResult | null => { - // Strategy B first (cheapest — single map lookup): Check local file - const localNodeId = symbolTable.lookupExact(currentFile, calledName); - if (localNodeId) { - return { nodeId: localNodeId, confidence: 0.85, reason: 'same-file' }; - } + const tiered = ctx.resolve(call.calledName, currentFile); + if (!tiered) return null; - // Strategy A: Check if any definition of calledName is in an imported file - // Reversed: instead of iterating all imports and checking each, get all definitions - // and check if any is imported. O(definitions) instead of O(imports). - const allDefs = symbolTable.lookupFuzzy(calledName); - if (allDefs.length > 0) { - const importedFiles = importMap.get(currentFile); - if (importedFiles) { - for (const def of allDefs) { - if (importedFiles.has(def.filePath)) { - return { nodeId: def.nodeId, confidence: 0.9, reason: 'import-resolved' }; - } + const filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm); + + // D. Receiver-type filtering: for member calls with a known receiver type, + // resolve the type through the same tiered import infrastructure, then + // filter method candidates to the type's defining file. Fall back to + // fuzzy ownerId matching only when file-based narrowing is inconclusive. + // + // Applied regardless of candidate count — the sole same-file candidate may + // belong to the wrong class (e.g. super.save() should hit the parent's save, + // not the child's own save method in the same file). + if (call.callForm === 'member' && call.receiverTypeName) { + // D1. Resolve the receiver type + const typeResolved = ctx.resolve(call.receiverTypeName, currentFile); + if (typeResolved && typeResolved.candidates.length > 0) { + const typeNodeIds = new Set(typeResolved.candidates.map(d => d.nodeId)); + const typeFiles = new Set(typeResolved.candidates.map(d => d.filePath)); + + // D2. Widen candidates: same-file tier may miss the parent's method when + // it lives in another file. Query the symbol table directly for all + // global methods with this name, then apply arity/kind filtering. + const methodPool = filteredCandidates.length <= 1 + ? filterCallableCandidates(ctx.symbols.lookupFuzzy(call.calledName), call.argCount, call.callForm) + : filteredCandidates; + + // D3. File-based: prefer candidates whose filePath matches the resolved type's file + const fileFiltered = methodPool.filter(c => typeFiles.has(c.filePath)); + if (fileFiltered.length === 1) { + return toResolveResult(fileFiltered[0], tiered.tier); } - } - // Strategy C: Fuzzy global (no import match found) - const confidence = allDefs.length === 1 ? 0.5 : 0.3; - return { nodeId: allDefs[0].nodeId, confidence, reason: 'fuzzy-global' }; + // D4. ownerId fallback: narrow by ownerId matching the type's nodeId + const pool = fileFiltered.length > 0 ? fileFiltered : methodPool; + const ownerFiltered = pool.filter(c => c.ownerId && typeNodeIds.has(c.ownerId)); + if (ownerFiltered.length === 1) { + return toResolveResult(ownerFiltered[0], tiered.tier); + } + if (fileFiltered.length > 1 || ownerFiltered.length > 1) return null; + } } - return null; + if (filteredCandidates.length !== 1) return null; + + return toResolveResult(filteredCandidates[0], tiered.tier); +}; + +// ── Scope key helpers ──────────────────────────────────────────────────── +// Scope keys use the format "funcName@startIndex" (produced by type-env.ts). +// Source IDs use "Label:filepath:funcName" (produced by parse-worker.ts). +// NUL (\0) is used as a composite-key separator because it cannot appear +// in source-code identifiers, preventing ambiguous concatenation. +// +// receiverKey stores the FULL scope (funcName@startIndex) to prevent +// collisions between overloaded methods with the same name in different +// classes (e.g. User.save@100 and Repo.save@200 are distinct keys). +// Lookup uses a secondary funcName-only index built in lookupReceiverType. + +/** Extract the function name from a scope key ("funcName@startIndex" → "funcName"). */ +const extractFuncNameFromScope = (scope: string): string => + scope.slice(0, scope.indexOf('@')); + +/** Extract the trailing function name from a sourceId ("Function:filepath:funcName" → "funcName"). */ +const extractFuncNameFromSourceId = (sourceId: string): string => { + const lastColon = sourceId.lastIndexOf(':'); + return lastColon >= 0 ? sourceId.slice(lastColon + 1) : ''; }; /** - * Filter out common built-in functions and noise - * that shouldn't be tracked as calls + * Build a composite key for receiver type storage. + * Uses the full scope string (e.g. "save@100") to distinguish overloaded + * methods with the same name in different classes. */ -const isBuiltInOrNoise = (name: string): boolean => { - const builtIns = new Set([ - // JavaScript/TypeScript built-ins - 'console', 'log', 'warn', 'error', 'info', 'debug', - 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', - 'parseInt', 'parseFloat', 'isNaN', 'isFinite', - 'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent', - 'JSON', 'parse', 'stringify', - 'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt', - 'Map', 'Set', 'WeakMap', 'WeakSet', - 'Promise', 'resolve', 'reject', 'then', 'catch', 'finally', - 'Math', 'Date', 'RegExp', 'Error', - 'require', 'import', 'export', - 'fetch', 'Response', 'Request', - // React hooks and common functions - 'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext', - 'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue', - 'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy', - // Common array/object methods - 'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every', - 'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split', - 'push', 'pop', 'shift', 'unshift', 'sort', 'reverse', - 'keys', 'values', 'entries', 'assign', 'freeze', 'seal', - 'hasOwnProperty', 'toString', 'valueOf', - // Python built-ins - 'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple', - 'open', 'read', 'write', 'close', 'append', 'extend', 'update', - 'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr', - 'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs', - ]); +const receiverKey = (scope: string, varName: string): string => + `${scope}\0${varName}`; - return builtIns.has(name); +/** + * Pre-built secondary index for O(1) receiver type lookups. + * Built once per file from the verified receiver map, keyed by funcName → varName. + */ +type ReceiverTypeEntry = + | { readonly kind: 'resolved'; readonly value: string } + | { readonly kind: 'ambiguous' }; +type ReceiverTypeIndex = Map<string, Map<string, ReceiverTypeEntry>>; + +/** + * Build a two-level secondary index from the verified receiver map. + * The verified map is keyed by `scope\0varName` where scope is either + * "funcName@startIndex" (inside a function) or "" (file level). + * Index structure: Map<funcName, Map<varName, ReceiverTypeEntry>> + */ +const buildReceiverTypeIndex = (map: Map<string, string>): ReceiverTypeIndex => { + const index: ReceiverTypeIndex = new Map(); + for (const [key, typeName] of map) { + const nul = key.indexOf('\0'); + if (nul < 0) continue; + const scope = key.slice(0, nul); + const varName = key.slice(nul + 1); + if (!varName) continue; + if (scope !== '' && !scope.includes('@')) continue; + const funcName = scope === '' ? '' : scope.slice(0, scope.indexOf('@')); + + let varMap = index.get(funcName); + if (!varMap) { varMap = new Map(); index.set(funcName, varMap); } + + const existing = varMap.get(varName); + if (existing === undefined) { + varMap.set(varName, { kind: 'resolved', value: typeName }); + } else if (existing.kind === 'resolved' && existing.value !== typeName) { + varMap.set(varName, { kind: 'ambiguous' }); + } + } + return index; +}; + +/** + * O(1) receiver type lookup using the pre-built secondary index. + * Returns the unique type name if unambiguous. Falls back to file-level scope. + */ +const lookupReceiverType = ( + index: ReceiverTypeIndex, + funcName: string, + varName: string, +): string | undefined => { + const funcBucket = index.get(funcName); + if (funcBucket) { + const entry = funcBucket.get(varName); + if (entry?.kind === 'resolved') return entry.value; + if (entry?.kind === 'ambiguous') { + // Ambiguous in this function scope — try file-level fallback + const fileEntry = index.get('')?.get(varName); + return fileEntry?.kind === 'resolved' ? fileEntry.value : undefined; + } + } + // Fallback: file-level scope (funcName "") + if (funcName !== '') { + const fileEntry = index.get('')?.get(varName); + if (fileEntry?.kind === 'resolved') return fileEntry.value; + } + return undefined; +}; + +interface FieldResolution { + typeName: string; // resolved declared type (continues chain threading) + fieldNodeId: string; // nodeId of the Property symbol (for ACCESSES edge target) +} + +/** + * Resolve the type that results from accessing `receiverName.fieldName`. + * Requires declaredType on the Property node (needed for chain walking continuation). + */ +const resolveFieldAccessType = ( + receiverName: string, + fieldName: string, + filePath: string, + ctx: ResolutionContext, +): FieldResolution | undefined => { + const fieldDef = resolveFieldOwnership(receiverName, fieldName, filePath, ctx); + if (!fieldDef?.declaredType) return undefined; + + // Use stripNullable (not extractReturnTypeName) — field types like List<User> + // should be preserved as-is, not unwrapped to User. Only strip nullable wrappers. + return { + typeName: stripNullable(fieldDef.declaredType), + fieldNodeId: fieldDef.nodeId, + }; +}; + +/** + * Resolve a field's Property node given a receiver type name and field name. + * Does NOT require declaredType — used by write-access tracking where only the + * fieldNodeId is needed (no chain continuation). + */ +const resolveFieldOwnership = ( + receiverName: string, + fieldName: string, + filePath: string, + ctx: ResolutionContext, +): { nodeId: string; declaredType?: string } | undefined => { + const typeResolved = ctx.resolve(receiverName, filePath); + if (!typeResolved) return undefined; + const classDef = typeResolved.candidates.find( + d => d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface' + || d.type === 'Enum' || d.type === 'Record' || d.type === 'Impl', + ); + if (!classDef) return undefined; + + return ctx.symbols.lookupFieldByOwner(classDef.nodeId, fieldName) ?? undefined; +}; + +/** + * Create a deduplicated ACCESSES edge emitter for a single source node. + * Each (sourceId, fieldNodeId) pair is emitted at most once per source. + */ +const makeAccessEmitter = ( + graph: KnowledgeGraph, + sourceId: string, +): OnFieldResolved => { + const emitted = new Set<string>(); + return (fieldNodeId: string): void => { + const key = `${sourceId}\0${fieldNodeId}`; + if (emitted.has(key)) return; + emitted.add(key); + + graph.addRelationship({ + id: generateId('ACCESSES', `${sourceId}:${fieldNodeId}:read`), + sourceId, + targetId: fieldNodeId, + type: 'ACCESSES', + confidence: 1.0, + reason: 'read', + }); + }; +}; + +/** + * Walk a pre-built mixed chain of field/call steps, threading the current type + * through each step and returning the final resolved type. + * + * Returns `undefined` if any step cannot be resolved (chain is broken). + * The caller is responsible for seeding `startType` from its own context + * (TypeEnv, constructor bindings, or static-class fallback). + */ +type OnFieldResolved = (fieldNodeId: string) => void; + +const walkMixedChain = ( + chain: MixedChainStep[], + startType: string, + filePath: string, + ctx: ResolutionContext, + onFieldResolved?: OnFieldResolved, +): string | undefined => { + let currentType: string | undefined = startType; + for (const step of chain) { + if (!currentType) break; + if (step.kind === 'field') { + const resolved = resolveFieldAccessType(currentType, step.name, filePath, ctx); + if (!resolved) { currentType = undefined; break; } + onFieldResolved?.(resolved.fieldNodeId); + currentType = resolved.typeName; + } else { + // Ruby/Python: property access is syntactically identical to method calls. + // Try field resolution first — if the name is a known property with declaredType, + // use that type directly. Otherwise fall back to method call resolution. + const fieldResolved = resolveFieldAccessType(currentType, step.name, filePath, ctx); + if (fieldResolved) { + onFieldResolved?.(fieldResolved.fieldNodeId); + currentType = fieldResolved.typeName; + continue; + } + const resolved = resolveCallTarget( + { calledName: step.name, callForm: 'member', receiverTypeName: currentType }, + filePath, + ctx, + ); + if (!resolved) { + // Stdlib passthrough: unwrap(), clone(), etc. preserve the receiver type + if (TYPE_PRESERVING_METHODS.has(step.name)) continue; + currentType = undefined; break; + } + if (!resolved.returnType) { currentType = undefined; break; } + const retType = extractReturnTypeName(resolved.returnType); + if (!retType) { currentType = undefined; break; } + currentType = retType; + } + } + return currentType; }; /** * Fast path: resolve pre-extracted call sites from workers. * No AST parsing — workers already extracted calledName + sourceId. - * This function only does symbol table lookups + graph mutations. */ export const processCallsFromExtracted = async ( graph: KnowledgeGraph, extractedCalls: ExtractedCall[], - symbolTable: SymbolTable, - importMap: ImportMap, - onProgress?: (current: number, total: number) => void + ctx: ResolutionContext, + onProgress?: (current: number, total: number) => void, + constructorBindings?: FileConstructorBindings[], ) => { - // Group by file for progress reporting + // Scope-aware receiver types: keyed by filePath → "funcName\0varName" → typeName. + // The scope dimension prevents collisions when two functions in the same file + // have same-named locals pointing to different constructor types. + const fileReceiverTypes = new Map<string, ReceiverTypeIndex>(); + if (constructorBindings) { + for (const { filePath, bindings } of constructorBindings) { + const verified = verifyConstructorBindings(bindings, filePath, ctx, graph); + if (verified.size > 0) { + fileReceiverTypes.set(filePath, buildReceiverTypeIndex(verified)); + } + } + } + const byFile = new Map<string, ExtractedCall[]>(); for (const call of extractedCalls) { let list = byFile.get(call.filePath); - if (!list) { - list = []; - byFile.set(call.filePath, list); - } + if (!list) { list = []; byFile.set(call.filePath, list); } list.push(call); } - const totalFiles = byFile.size; let filesProcessed = 0; - for (const [_filePath, calls] of byFile) { + for (const [filePath, calls] of byFile) { filesProcessed++; if (filesProcessed % 100 === 0) { onProgress?.(filesProcessed, totalFiles); await yieldToEventLoop(); } + ctx.enableCache(filePath); + const receiverMap = fileReceiverTypes.get(filePath); + for (const call of calls) { - const resolved = resolveCallTarget( - call.calledName, - call.filePath, - symbolTable, - importMap - ); + let effectiveCall = call; + + // Step 1: resolve receiver type from constructor bindings + if (!call.receiverTypeName && call.receiverName && receiverMap) { + const callFuncName = extractFuncNameFromSourceId(call.sourceId); + const resolvedType = lookupReceiverType(receiverMap, callFuncName, call.receiverName); + if (resolvedType) { + effectiveCall = { ...call, receiverTypeName: resolvedType }; + } + } + + // Step 1b: class-as-receiver for static method calls (e.g. UserService.find_user()) + if (!effectiveCall.receiverTypeName && effectiveCall.receiverName && effectiveCall.callForm === 'member') { + const typeResolved = ctx.resolve(effectiveCall.receiverName, effectiveCall.filePath); + if (typeResolved && typeResolved.candidates.some( + d => d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct' || d.type === 'Enum', + )) { + effectiveCall = { ...effectiveCall, receiverTypeName: effectiveCall.receiverName }; + } + } + + // Step 1c: mixed chain resolution (field, call, or interleaved — e.g. svc.getUser().address.save()). + // Runs whenever receiverMixedChain is present. Steps 1/1b may have resolved the base receiver + // type already; that type is used as the chain's starting point. + if (effectiveCall.receiverMixedChain?.length) { + // Use the already-resolved base type (from Steps 1/1b) or look it up now. + let currentType: string | undefined = effectiveCall.receiverTypeName; + if (!currentType && effectiveCall.receiverName && receiverMap) { + const callFuncName = extractFuncNameFromSourceId(effectiveCall.sourceId); + currentType = lookupReceiverType(receiverMap, callFuncName, effectiveCall.receiverName); + } + if (!currentType && effectiveCall.receiverName) { + const typeResolved = ctx.resolve(effectiveCall.receiverName, effectiveCall.filePath); + if (typeResolved?.candidates.some(d => + d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct' || d.type === 'Enum', + )) { + currentType = effectiveCall.receiverName; + } + } + if (currentType) { + const walkedType = walkMixedChain( + effectiveCall.receiverMixedChain, currentType, effectiveCall.filePath, ctx, + makeAccessEmitter(graph, effectiveCall.sourceId), + ); + if (walkedType) { + effectiveCall = { ...effectiveCall, receiverTypeName: walkedType }; + } + } + } + + const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx); if (!resolved) continue; - const relId = generateId('CALLS', `${call.sourceId}:${call.calledName}->${resolved.nodeId}`); + const relId = generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${resolved.nodeId}`); graph.addRelationship({ id: relId, - sourceId: call.sourceId, + sourceId: effectiveCall.sourceId, targetId: resolved.nodeId, type: 'CALLS', confidence: resolved.confidence, reason: resolved.reason, }); } + + ctx.clearCache(); } onProgress?.(totalFiles, totalFiles); }; + +/** + * Resolve pre-extracted field write assignments to ACCESSES {reason: 'write'} edges. + * Accepts optional constructorBindings for return-type-aware receiver inference, + * mirroring processCallsFromExtracted's verified binding lookup. + */ +export const processAssignmentsFromExtracted = ( + graph: KnowledgeGraph, + assignments: ExtractedAssignment[], + ctx: ResolutionContext, + constructorBindings?: FileConstructorBindings[], +): void => { + // Build per-file receiver type indexes from verified constructor bindings + const fileReceiverTypes = new Map<string, ReceiverTypeIndex>(); + if (constructorBindings) { + for (const { filePath, bindings } of constructorBindings) { + const verified = verifyConstructorBindings(bindings, filePath, ctx, graph); + if (verified.size > 0) { + fileReceiverTypes.set(filePath, buildReceiverTypeIndex(verified)); + } + } + } + + for (const asn of assignments) { + // Resolve the receiver type + let receiverTypeName = asn.receiverTypeName; + // Tier 2: verified constructor bindings (return-type inference) + if (!receiverTypeName && fileReceiverTypes.size > 0) { + const receiverMap = fileReceiverTypes.get(asn.filePath); + if (receiverMap) { + const funcName = extractFuncNameFromSourceId(asn.sourceId); + receiverTypeName = lookupReceiverType(receiverMap, funcName, asn.receiverText); + } + } + // Tier 3: static class-as-receiver fallback + if (!receiverTypeName) { + const resolved = ctx.resolve(asn.receiverText, asn.filePath); + if (resolved?.candidates.some(d => + d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface' + || d.type === 'Enum' || d.type === 'Record' || d.type === 'Impl', + )) { + receiverTypeName = asn.receiverText; + } + } + if (!receiverTypeName) continue; + const fieldOwner = resolveFieldOwnership(receiverTypeName, asn.propertyName, asn.filePath, ctx); + if (!fieldOwner) continue; + graph.addRelationship({ + id: generateId('ACCESSES', `${asn.sourceId}:${fieldOwner.nodeId}:write`), + sourceId: asn.sourceId, + targetId: fieldOwner.nodeId, + type: 'ACCESSES', + confidence: 1.0, + reason: 'write', + }); + } +}; + +/** + * Resolve pre-extracted Laravel routes to CALLS edges from route files to controller methods. + */ +export const processRoutesFromExtracted = async ( + graph: KnowledgeGraph, + extractedRoutes: ExtractedRoute[], + ctx: ResolutionContext, + onProgress?: (current: number, total: number) => void, +) => { + for (let i = 0; i < extractedRoutes.length; i++) { + const route = extractedRoutes[i]; + if (i % 50 === 0) { + onProgress?.(i, extractedRoutes.length); + await yieldToEventLoop(); + } + + if (!route.controllerName || !route.methodName) continue; + + const controllerResolved = ctx.resolve(route.controllerName, route.filePath); + if (!controllerResolved || controllerResolved.candidates.length === 0) continue; + if (controllerResolved.tier === 'global' && controllerResolved.candidates.length > 1) continue; + + const controllerDef = controllerResolved.candidates[0]; + const confidence = TIER_CONFIDENCE[controllerResolved.tier]; + + const methodResolved = ctx.resolve(route.methodName, controllerDef.filePath); + const methodId = methodResolved?.tier === 'same-file' ? methodResolved.candidates[0]?.nodeId : undefined; + const sourceId = generateId('File', route.filePath); + + if (!methodId) { + const guessedId = generateId('Method', `${controllerDef.filePath}:${route.methodName}`); + const relId = generateId('CALLS', `${sourceId}:route->${guessedId}`); + graph.addRelationship({ + id: relId, + sourceId, + targetId: guessedId, + type: 'CALLS', + confidence: confidence * 0.8, + reason: 'laravel-route', + }); + continue; + } + + const relId = generateId('CALLS', `${sourceId}:route->${methodId}`); + graph.addRelationship({ + id: relId, + sourceId, + targetId: methodId, + type: 'CALLS', + confidence, + reason: 'laravel-route', + }); + } + + onProgress?.(extractedRoutes.length, extractedRoutes.length); +}; diff --git a/gitnexus/src/core/ingestion/call-routing.ts b/gitnexus/src/core/ingestion/call-routing.ts new file mode 100644 index 0000000000..c86f180746 --- /dev/null +++ b/gitnexus/src/core/ingestion/call-routing.ts @@ -0,0 +1,171 @@ +/** + * Shared Ruby call routing logic. + * + * Ruby expresses imports, heritage (mixins), and property definitions as + * method calls rather than syntax-level constructs. This module provides a + * routing function used by the CLI call-processor, CLI parse-worker, and + * the web call-processor so that the classification logic lives in one place. + * + * NOTE: This file is intentionally duplicated in gitnexus-web/ because the + * two packages have separate build targets (Node native vs WASM/browser). + * Keep both copies in sync until a shared package is introduced. + */ + +import { SupportedLanguages } from '../../config/supported-languages.js'; + +// ── Call routing dispatch table ───────────────────────────────────────────── + +/** null = this call was not routed; fall through to default call handling */ +export type CallRoutingResult = RubyCallRouting | null; + +export type CallRouter = ( + calledName: string, + callNode: any, +) => CallRoutingResult; + +/** No-op router: returns null for every call (passthrough to normal processing) */ +const noRouting: CallRouter = () => null; + +/** Per-language call routing. noRouting = no special routing (normal call processing) */ +export const callRouters = { + [SupportedLanguages.JavaScript]: noRouting, + [SupportedLanguages.TypeScript]: noRouting, + [SupportedLanguages.Python]: noRouting, + [SupportedLanguages.Java]: noRouting, + [SupportedLanguages.Kotlin]: noRouting, + [SupportedLanguages.Go]: noRouting, + [SupportedLanguages.Rust]: noRouting, + [SupportedLanguages.CSharp]: noRouting, + [SupportedLanguages.PHP]: noRouting, + [SupportedLanguages.Swift]: noRouting, + [SupportedLanguages.CPlusPlus]: noRouting, + [SupportedLanguages.C]: noRouting, + [SupportedLanguages.Ruby]: routeRubyCall, +} satisfies Record<SupportedLanguages, CallRouter>; + +// ── Result types ──────────────────────────────────────────────────────────── + +export type RubyCallRouting = + | { kind: 'import'; importPath: string; isRelative: boolean } + | { kind: 'heritage'; items: RubyHeritageItem[] } + | { kind: 'properties'; items: RubyPropertyItem[] } + | { kind: 'call' } + | { kind: 'skip' }; + +export interface RubyHeritageItem { + enclosingClass: string; + mixinName: string; + heritageKind: 'include' | 'extend' | 'prepend'; +} + +export type RubyAccessorType = 'attr_accessor' | 'attr_reader' | 'attr_writer'; + +export interface RubyPropertyItem { + propName: string; + accessorType: RubyAccessorType; + startLine: number; + endLine: number; + /** YARD @return [Type] annotation preceding the attr_accessor call */ + declaredType?: string; +} + +// ── Pre-allocated singletons for common return values ──────────────────────── +const CALL_RESULT: RubyCallRouting = { kind: 'call' }; +const SKIP_RESULT: RubyCallRouting = { kind: 'skip' }; + +/** Max depth for parent-walking loops to prevent pathological AST traversals */ +const MAX_PARENT_DEPTH = 50; + +// ── Routing function ──────────────────────────────────────────────────────── + +/** + * Classify a Ruby call node and extract its semantic payload. + * + * @param calledName - The method name (e.g. 'require', 'include', 'attr_accessor') + * @param callNode - The tree-sitter `call` AST node + * @returns A discriminated union describing the call's semantic role + */ +export function routeRubyCall(calledName: string, callNode: any): RubyCallRouting { + // ── require / require_relative → import ───────────────────────────────── + if (calledName === 'require' || calledName === 'require_relative') { + const argList = callNode.childForFieldName?.('arguments'); + const stringNode = argList?.children?.find((c: any) => c.type === 'string'); + const contentNode = stringNode?.children?.find((c: any) => c.type === 'string_content'); + if (!contentNode) return SKIP_RESULT; + + let importPath: string = contentNode.text; + // Validate: reject null bytes, control chars, excessively long paths + if (!importPath || importPath.length > 1024 || /[\x00-\x1f]/.test(importPath)) { + return SKIP_RESULT; + } + const isRelative = calledName === 'require_relative'; + if (isRelative && !importPath.startsWith('.')) { + importPath = './' + importPath; + } + return { kind: 'import', importPath, isRelative }; + } + + // ── include / extend / prepend → heritage (mixin) ────────────────────── + if (calledName === 'include' || calledName === 'extend' || calledName === 'prepend') { + let enclosingClass: string | null = null; + let current = callNode.parent; + let depth = 0; + while (current && ++depth <= MAX_PARENT_DEPTH) { + if (current.type === 'class' || current.type === 'module') { + const nameNode = current.childForFieldName?.('name'); + if (nameNode) { enclosingClass = nameNode.text; break; } + } + current = current.parent; + } + if (!enclosingClass) return SKIP_RESULT; + + const items: RubyHeritageItem[] = []; + const argList = callNode.childForFieldName?.('arguments'); + for (const arg of (argList?.children ?? [])) { + if (arg.type === 'constant' || arg.type === 'scope_resolution') { + items.push({ enclosingClass, mixinName: arg.text, heritageKind: calledName as 'include' | 'extend' | 'prepend' }); + } + } + return items.length > 0 ? { kind: 'heritage', items } : SKIP_RESULT; + } + + // ── attr_accessor / attr_reader / attr_writer → property definitions ─── + if (calledName === 'attr_accessor' || calledName === 'attr_reader' || calledName === 'attr_writer') { + // Extract YARD @return [Type] from preceding comment (e.g. `# @return [Address]`) + let yardType: string | undefined; + let sibling = callNode.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + const match = /@return\s+\[([^\]]+)\]/.exec(sibling.text); + if (match) { + const raw = match[1].trim(); + // Extract simple type name: "User", "Array<User>" → "User" + const simple = raw.match(/^([A-Z]\w*)/); + if (simple) yardType = simple[1]; + break; + } + } else if (sibling.isNamed) { + break; // stop at non-comment named sibling + } + sibling = sibling.previousSibling; + } + + const items: RubyPropertyItem[] = []; + const argList = callNode.childForFieldName?.('arguments'); + for (const arg of (argList?.children ?? [])) { + if (arg.type === 'simple_symbol') { + items.push({ + propName: arg.text.startsWith(':') ? arg.text.slice(1) : arg.text, + accessorType: calledName as RubyAccessorType, + startLine: arg.startPosition.row, + endLine: arg.endPosition.row, + ...(yardType ? { declaredType: yardType } : {}), + }); + } + } + return items.length > 0 ? { kind: 'properties', items } : SKIP_RESULT; + } + + // ── Everything else → regular call ───────────────────────────────────── + return CALL_RESULT; +} diff --git a/gitnexus/src/core/ingestion/community-processor.ts b/gitnexus/src/core/ingestion/community-processor.ts index 369715b665..2cafb94699 100644 --- a/gitnexus/src/core/ingestion/community-processor.ts +++ b/gitnexus/src/core/ingestion/community-processor.ts @@ -90,12 +90,18 @@ export const processCommunities = async ( ): Promise<CommunityDetectionResult> => { onProgress?.('Building graph for community detection...', 0); - // Step 1: Build a graphology graph from the knowledge graph - // We only include symbol nodes (Function, Class, Method) and CALLS edges - const graph = buildGraphologyGraph(knowledgeGraph); - + // Pre-check total symbol count to determine large-graph mode before building + let symbolCount = 0; + knowledgeGraph.forEachNode(node => { + if (node.label === 'Function' || node.label === 'Class' || node.label === 'Method' || node.label === 'Interface') { + symbolCount++; + } + }); + const isLarge = symbolCount > 10_000; + + const graph = buildGraphologyGraph(knowledgeGraph, isLarge); + if (graph.order === 0) { - // No nodes to cluster return { communities: [], memberships: [], @@ -103,13 +109,37 @@ export const processCommunities = async ( }; } - onProgress?.(`Running Leiden algorithm on ${graph.order} nodes...`, 30); + const nodeCount = graph.order; + const edgeCount = graph.size; - // Step 2: Run Leiden algorithm for community detection - const details = (leiden as any).detailed(graph, { - resolution: 1.0, // Default resolution, can be tuned - randomWalk: true, - }); + onProgress?.(`Running Leiden on ${nodeCount} nodes, ${edgeCount} edges${isLarge ? ` (filtered from ${symbolCount} symbols)` : ''}...`, 30); + + // Large graphs: higher resolution + capped iterations (matching Python leidenalg default of 2). + // The first 2 iterations capture ~95%+ of modularity; additional iterations have diminishing returns. + // Timeout: abort after 60s for pathological graph structures. + const LEIDEN_TIMEOUT_MS = 60_000; + let details: any; + try { + details = await Promise.race([ + Promise.resolve((leiden as any).detailed(graph, { + resolution: isLarge ? 2.0 : 1.0, + maxIterations: isLarge ? 3 : 0, + })), + new Promise((_, reject) => + setTimeout(() => reject(new Error('Leiden timeout')), LEIDEN_TIMEOUT_MS) + ), + ]); + } catch (e: any) { + if (e.message === 'Leiden timeout') { + onProgress?.('Community detection timed out, using fallback...', 60); + // Fallback: assign all nodes to community 0 + const communities: Record<string, number> = {}; + graph.forEachNode((node: string) => { communities[node] = 0; }); + details = { communities, count: 1, modularity: 0 }; + } else { + throw e; + } + } onProgress?.(`Found ${details.count} communities...`, 60); @@ -150,46 +180,49 @@ export const processCommunities = async ( // ============================================================================ /** - * Build a graphology graph containing only symbol nodes and CALLS edges - * This is what the Leiden algorithm will cluster + * Build a graphology graph containing only symbol nodes and clustering edges. + * For large graphs (>10K symbols), filter out low-confidence fuzzy-global edges + * and degree-1 nodes that add noise and massively increase Leiden runtime. */ -const buildGraphologyGraph = (knowledgeGraph: KnowledgeGraph): any => { - // Use undirected graph for Leiden - it looks at edge density, not direction +const MIN_CONFIDENCE_LARGE = 0.5; + +const buildGraphologyGraph = (knowledgeGraph: KnowledgeGraph, isLarge: boolean): any => { const graph = new (Graph as any)({ type: 'undirected', allowSelfLoops: false }); - // Symbol types that should be clustered const symbolTypes = new Set<NodeLabel>(['Function', 'Class', 'Method', 'Interface']); - - // First pass: collect which nodes participate in clustering edges const clusteringRelTypes = new Set(['CALLS', 'EXTENDS', 'IMPLEMENTS']); const connectedNodes = new Set<string>(); + const nodeDegree = new Map<string, number>(); - knowledgeGraph.relationships.forEach(rel => { - if (clusteringRelTypes.has(rel.type) && rel.sourceId !== rel.targetId) { - connectedNodes.add(rel.sourceId); - connectedNodes.add(rel.targetId); - } + knowledgeGraph.forEachRelationship(rel => { + if (!clusteringRelTypes.has(rel.type) || rel.sourceId === rel.targetId) return; + if (isLarge && rel.confidence < MIN_CONFIDENCE_LARGE) return; + + connectedNodes.add(rel.sourceId); + connectedNodes.add(rel.targetId); + nodeDegree.set(rel.sourceId, (nodeDegree.get(rel.sourceId) || 0) + 1); + nodeDegree.set(rel.targetId, (nodeDegree.get(rel.targetId) || 0) + 1); }); - // Only add nodes that have at least one clustering edge - // Isolated nodes would just become singletons (skipped anyway) - knowledgeGraph.nodes.forEach(node => { - if (symbolTypes.has(node.label) && connectedNodes.has(node.id)) { - graph.addNode(node.id, { - name: node.properties.name, - filePath: node.properties.filePath, - type: node.label, - }); - } + knowledgeGraph.forEachNode(node => { + if (!symbolTypes.has(node.label) || !connectedNodes.has(node.id)) return; + // For large graphs, skip degree-1 nodes — they just become singletons or + // get absorbed into their single neighbor's community, but cost iteration time. + if (isLarge && (nodeDegree.get(node.id) || 0) < 2) return; + + graph.addNode(node.id, { + name: node.properties.name, + filePath: node.properties.filePath, + type: node.label, + }); }); - // Add edges - knowledgeGraph.relationships.forEach(rel => { - if (clusteringRelTypes.has(rel.type)) { - if (graph.hasNode(rel.sourceId) && graph.hasNode(rel.targetId) && rel.sourceId !== rel.targetId) { - if (!graph.hasEdge(rel.sourceId, rel.targetId)) { - graph.addEdge(rel.sourceId, rel.targetId); - } + knowledgeGraph.forEachRelationship(rel => { + if (!clusteringRelTypes.has(rel.type)) return; + if (isLarge && rel.confidence < MIN_CONFIDENCE_LARGE) return; + if (graph.hasNode(rel.sourceId) && graph.hasNode(rel.targetId) && rel.sourceId !== rel.targetId) { + if (!graph.hasEdge(rel.sourceId, rel.targetId)) { + graph.addEdge(rel.sourceId, rel.targetId); } } }); @@ -222,11 +255,11 @@ const createCommunityNodes = ( // Build node lookup for file paths const nodePathMap = new Map<string, string>(); - knowledgeGraph.nodes.forEach(node => { + for (const node of knowledgeGraph.iterNodes()) { if (node.properties.filePath) { nodePathMap.set(node.id, node.properties.filePath); } - }); + } // Create community nodes - SKIP SINGLETONS (isolated nodes) const communityNodes: CommunityNode[] = []; diff --git a/gitnexus/src/core/ingestion/constants.ts b/gitnexus/src/core/ingestion/constants.ts new file mode 100644 index 0000000000..81f1107e14 --- /dev/null +++ b/gitnexus/src/core/ingestion/constants.ts @@ -0,0 +1,19 @@ +/** + * Default minimum buffer size for tree-sitter parsing (512 KB). + * tree-sitter requires bufferSize >= file size in bytes. + */ +export const TREE_SITTER_BUFFER_SIZE = 512 * 1024; + +/** + * Maximum buffer size cap (32 MB) to prevent OOM on huge files. + * Also used as the file-size skip threshold — files larger than this are not parsed. + */ +export const TREE_SITTER_MAX_BUFFER = 32 * 1024 * 1024; + +/** + * Compute adaptive buffer size for tree-sitter parsing. + * Uses 2× file size, clamped between 512 KB and 32 MB. + * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB). + */ +export const getTreeSitterBufferSize = (contentLength: number): number => + Math.min(Math.max(contentLength * 2, TREE_SITTER_BUFFER_SIZE), TREE_SITTER_MAX_BUFFER); diff --git a/gitnexus/src/core/ingestion/entry-point-scoring.ts b/gitnexus/src/core/ingestion/entry-point-scoring.ts index 55d0b1035f..b58bbe33d5 100644 --- a/gitnexus/src/core/ingestion/entry-point-scoring.ts +++ b/gitnexus/src/core/ingestion/entry-point-scoring.ts @@ -11,9 +11,10 @@ */ import { detectFrameworkFromPath } from './framework-detection.js'; +import { SupportedLanguages } from '../../config/supported-languages.js'; // ============================================================================ -// NAME PATTERNS - All 9 supported languages +// NAME PATTERNS - All 11 supported languages // ============================================================================ /** @@ -38,39 +39,47 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = { ], // JavaScript/TypeScript - 'javascript': [ + [SupportedLanguages.JavaScript]: [ /^use[A-Z]/, // React hooks (useEffect, etc.) ], - 'typescript': [ + [SupportedLanguages.TypeScript]: [ /^use[A-Z]/, // React hooks ], - + // Python - 'python': [ + [SupportedLanguages.Python]: [ /^app$/, // Flask/FastAPI app /^(get|post|put|delete|patch)_/i, // REST conventions /^api_/, // API functions /^view_/, // Django views ], - + // Java - 'java': [ + [SupportedLanguages.Java]: [ /^do[A-Z]/, // doGet, doPost (Servlets) /^create[A-Z]/, // Factory patterns /^build[A-Z]/, // Builder patterns /Service$/, // UserService ], - + // C# - 'csharp': [ - /^(Get|Post|Put|Delete)/, // ASP.NET conventions - /Action$/, // MVC actions - /^On[A-Z]/, // Event handlers - /Async$/, // Async entry points + [SupportedLanguages.CSharp]: [ + /^(Get|Post|Put|Delete|Patch)/, // ASP.NET action methods + /Action$/, // MVC actions + /^On[A-Z]/, // Event handlers / Blazor lifecycle + /Async$/, // Async entry points + /^Configure$/, // Startup.Configure + /^ConfigureServices$/, // Startup.ConfigureServices + /^Handle$/, // MediatR / generic handler + /^Execute$/, // Command pattern + /^Invoke$/, // Middleware Invoke + /^Map[A-Z]/, // Minimal API MapGet, MapPost + /Service$/, // Service classes + /^Seed/, // Database seeding ], // Go - 'go': [ + [SupportedLanguages.Go]: [ /Handler$/, // http.Handler pattern /^Serve/, // ServeHTTP /^New[A-Z]/, // Constructor pattern (returns new instance) @@ -78,7 +87,7 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = { ], // Rust - 'rust': [ + [SupportedLanguages.Rust]: [ /^(get|post|put|delete)_handler$/i, /^handle_/, // handle_request /^new$/, // Constructor pattern @@ -86,24 +95,119 @@ const ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = { /^spawn/, // Async spawn ], - // C - explicit main() boost (critical for C programs) - 'c': [ + // C - explicit main() boost plus common C entry point conventions + [SupportedLanguages.C]: [ /^main$/, // THE entry point - /^init_/, // Initialization functions - /^start_/, // Start functions - /^run_/, // Run functions + /^init_/, // init_server, init_client + /_init$/, // module_init, server_init + /^start_/, // start_server + /_start$/, // thread_start + /^run_/, // run_loop + /_run$/, // event_run + /^stop_/, // stop_server + /_stop$/, // service_stop + /^open_/, // open_connection + /_open$/, // file_open + /^close_/, // close_connection + /_close$/, // socket_close + /^create_/, // create_session + /_create$/, // object_create + /^destroy_/, // destroy_session + /_destroy$/, // object_destroy + /^handle_/, // handle_request + /_handler$/, // signal_handler + /_callback$/, // event_callback + /^cmd_/, // tmux: cmd_new_window, cmd_attach_session + /^server_/, // server_start, server_loop + /^client_/, // client_connect + /^session_/, // session_create + /^window_/, // window_resize (tmux) + /^key_/, // key_press + /^input_/, // input_parse + /^output_/, // output_write + /^notify_/, // notify_client + /^control_/, // control_start ], - - // C++ - same as C plus class patterns - 'cpp': [ + + // C++ - same as C plus OOP/template patterns + [SupportedLanguages.CPlusPlus]: [ /^main$/, // THE entry point /^init_/, + /_init$/, /^Create[A-Z]/, // Factory patterns + /^create_/, /^Run$/, // Run methods + /^run$/, /^Start$/, // Start methods + /^start$/, + /^handle_/, + /_handler$/, + /_callback$/, + /^OnEvent/, // Event callbacks + /^on_/, + /::Run$/, // Class::Run + /::Start$/, // Class::Start + /::Init$/, // Class::Init + /::Execute$/, // Class::Execute + ], + + // Swift / iOS + [SupportedLanguages.Swift]: [ + /^viewDidLoad$/, // UIKit lifecycle + /^viewWillAppear$/, // UIKit lifecycle + /^viewDidAppear$/, // UIKit lifecycle + /^viewWillDisappear$/, // UIKit lifecycle + /^viewDidDisappear$/, // UIKit lifecycle + /^application\(/, // AppDelegate methods + /^scene\(/, // SceneDelegate methods + /^body$/, // SwiftUI View.body + /Coordinator$/, // Coordinator pattern + /^sceneDidBecomeActive$/, // SceneDelegate lifecycle + /^sceneWillResignActive$/, // SceneDelegate lifecycle + /^didFinishLaunchingWithOptions$/, // AppDelegate + /ViewController$/, // ViewController classes + /^configure[A-Z]/, // Configuration methods + /^setup[A-Z]/, // Setup methods + /^makeBody$/, // SwiftUI ViewModifier + ], + + // PHP / Laravel + [SupportedLanguages.PHP]: [ + /Controller$/, // UserController (class name convention) + /^handle$/, // Job::handle(), Listener::handle() + /^execute$/, // Command::execute() + /^boot$/, // ServiceProvider::boot() + /^register$/, // ServiceProvider::register() + /^__invoke$/, // Invokable controllers/actions + /^(index|show|store|update|destroy|create|edit)$/, // RESTful resource methods + /^(get|post|put|delete|patch)[A-Z]/, // Explicit HTTP method actions + /^run$/, // Command/Job run() + /^fire$/, // Event fire() + /^dispatch$/, // Dispatchable jobs + /Service$/, // UserService (Service layer) + /Repository$/, // UserRepository (Repository pattern) + /^find$/, // Repository::find() + /^findAll$/, // Repository::findAll() + /^save$/, // Repository::save() + /^delete$/, // Repository::delete() + ], + + // Ruby + [SupportedLanguages.Ruby]: [ + /^call$/, // Service objects (MyService.call) + /^perform$/, // Background jobs (Sidekiq, ActiveJob) + /^execute$/, // Command pattern ], }; +/** Pre-computed merged patterns (universal + language-specific) to avoid per-call array allocation. */ +const MERGED_ENTRY_POINT_PATTERNS: Record<string, RegExp[]> = {}; +const UNIVERSAL_PATTERNS = ENTRY_POINT_PATTERNS['*'] || []; +for (const [lang, patterns] of Object.entries(ENTRY_POINT_PATTERNS)) { + if (lang === '*') continue; + MERGED_ENTRY_POINT_PATTERNS[lang] = [...UNIVERSAL_PATTERNS, ...patterns]; +} + // ============================================================================ // UTILITY PATTERNS - Functions that should be penalized // ============================================================================ @@ -158,7 +262,7 @@ export interface EntryPointScoreResult { */ export function calculateEntryPointScore( name: string, - language: string, + language: SupportedLanguages, isExported: boolean, callerCount: number, calleeCount: number, @@ -191,9 +295,7 @@ export function calculateEntryPointScore( reasons.push('utility-pattern'); } else { // Check positive patterns - const universalPatterns = ENTRY_POINT_PATTERNS['*'] || []; - const langPatterns = ENTRY_POINT_PATTERNS[language] || []; - const allPatterns = [...universalPatterns, ...langPatterns]; + const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language] || UNIVERSAL_PATTERNS; if (allPatterns.some(p => p.test(name))) { nameMultiplier = 1.5; // Bonus for matching entry point pattern @@ -250,9 +352,28 @@ export function isTestFile(filePath: string): boolean { p.includes('/src/test/') || // Rust test patterns (inline tests are different, but test files) p.includes('/tests/') || + // Swift/iOS test patterns + p.endsWith('tests.swift') || + p.endsWith('test.swift') || + p.includes('uitests/') || // C# test patterns + p.endsWith('tests.cs') || + p.endsWith('test.cs') || p.includes('.tests/') || - p.includes('tests.cs') + p.includes('.test/') || + p.includes('.integrationtests/') || + p.includes('.unittests/') || + p.includes('/testproject/') || + // PHP/Laravel test patterns + p.endsWith('test.php') || + p.endsWith('spec.php') || + p.includes('/tests/feature/') || + p.includes('/tests/unit/') || + // Ruby test patterns + p.endsWith('_spec.rb') || + p.endsWith('_test.rb') || + p.includes('/spec/') || + p.includes('/test/fixtures/') ); } diff --git a/gitnexus/src/core/ingestion/export-detection.ts b/gitnexus/src/core/ingestion/export-detection.ts new file mode 100644 index 0000000000..e6c6e89df9 --- /dev/null +++ b/gitnexus/src/core/ingestion/export-detection.ts @@ -0,0 +1,243 @@ +/** + * Export Detection + * + * Determines whether a symbol (function, class, etc.) is exported/public + * in its language. This is a pure function — safe for use in worker threads. + * + * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback). + */ + +import { findSiblingChild, SyntaxNode } from './utils.js'; +import { SupportedLanguages } from '../../config/supported-languages.js'; + +/** Handler type: given a node and symbol name, return true if the symbol is exported/public. */ +type ExportChecker = (node: SyntaxNode, name: string) => boolean; + +// ============================================================================ +// Per-language export checkers +// ============================================================================ + +/** JS/TS: walk ancestors looking for export_statement or export_specifier. */ +const tsExportChecker: ExportChecker = (node, _name) => { + let current: SyntaxNode | null = node; + while (current) { + const type = current.type; + if (type === 'export_statement' || + type === 'export_specifier' || + (type === 'lexical_declaration' && current.parent?.type === 'export_statement')) { + return true; + } + // Fallback: check if node text starts with 'export ' for edge cases + if (current.text?.startsWith('export ')) { + return true; + } + current = current.parent; + } + return false; +}; + +/** Python: public if no leading underscore (convention). */ +const pythonExportChecker: ExportChecker = (_node, name) => !name.startsWith('_'); + +/** Java: check for 'public' modifier — modifiers are siblings of the name node, not parents. */ +const javaExportChecker: ExportChecker = (node, _name) => { + let current: SyntaxNode | null = node; + while (current) { + if (current.parent) { + const parent = current.parent; + for (let i = 0; i < parent.childCount; i++) { + const child = parent.child(i); + if (child?.type === 'modifiers' && child.text?.includes('public')) { + return true; + } + } + if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') { + if (parent.text?.trimStart().startsWith('public')) { + return true; + } + } + } + current = current.parent; + } + return false; +}; + +/** C# declaration node types for sibling modifier scanning. */ +const CSHARP_DECL_TYPES = new Set([ + 'method_declaration', 'local_function_statement', 'constructor_declaration', + 'class_declaration', 'interface_declaration', 'struct_declaration', + 'enum_declaration', 'record_declaration', 'record_struct_declaration', + 'record_class_declaration', 'delegate_declaration', + 'property_declaration', 'field_declaration', 'event_declaration', + 'namespace_declaration', 'file_scoped_namespace_declaration', +]); + +/** + * C#: modifier nodes are SIBLINGS of the name node inside the declaration. + * Walk up to the declaration node, then scan its direct children. + */ +const csharpExportChecker: ExportChecker = (node, _name) => { + let current: SyntaxNode | null = node; + while (current) { + if (CSHARP_DECL_TYPES.has(current.type)) { + for (let i = 0; i < current.childCount; i++) { + const child = current.child(i); + if (child?.type === 'modifier' && child.text === 'public') return true; + } + return false; + } + current = current.parent; + } + return false; +}; + +/** Go: uppercase first letter = exported. */ +const goExportChecker: ExportChecker = (_node, name) => { + if (name.length === 0) return false; + const first = name[0]; + return first === first.toUpperCase() && first !== first.toLowerCase(); +}; + +/** Rust declaration node types for sibling visibility_modifier scanning. */ +const RUST_DECL_TYPES = new Set([ + 'function_item', 'struct_item', 'enum_item', 'trait_item', 'impl_item', + 'union_item', 'type_item', 'const_item', 'static_item', 'mod_item', + 'use_declaration', 'associated_type', 'function_signature_item', +]); + +/** + * Rust: visibility_modifier is a SIBLING of the name node within the declaration node + * (function_item, struct_item, etc.), not a parent. Walk up to the declaration node, + * then scan its direct children. + */ +const rustExportChecker: ExportChecker = (node, _name) => { + let current: SyntaxNode | null = node; + while (current) { + if (RUST_DECL_TYPES.has(current.type)) { + for (let i = 0; i < current.childCount; i++) { + const child = current.child(i); + if (child?.type === 'visibility_modifier' && child.text?.startsWith('pub')) return true; + } + return false; + } + current = current.parent; + } + return false; +}; + +/** + * Kotlin: default visibility is public (unlike Java). + * visibility_modifier is inside modifiers, a sibling of the name node within the declaration. + */ +const kotlinExportChecker: ExportChecker = (node, _name) => { + let current: SyntaxNode | null = node; + while (current) { + if (current.parent) { + const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier'); + if (visMod) { + const text = visMod.text; + if (text === 'private' || text === 'internal' || text === 'protected') return false; + if (text === 'public') return true; + } + } + current = current.parent; + } + // No visibility modifier = public (Kotlin default) + return true; +}; + +/** + * C/C++: functions without 'static' storage class have external linkage by default, + * making them globally accessible (equivalent to exported). Only functions explicitly + * marked 'static' are file-scoped (not exported). C++ anonymous namespaces + * (namespace { ... }) also give internal linkage. + */ +const cCppExportChecker: ExportChecker = (node, _name) => { + let cur: SyntaxNode | null = node; + while (cur) { + if (cur.type === 'function_definition' || cur.type === 'declaration') { + // Check for 'static' storage class specifier as a direct child node. + // This avoids reading the full function text (which can be very large). + for (let i = 0; i < cur.childCount; i++) { + const child = cur.child(i); + if (child?.type === 'storage_class_specifier' && child.text === 'static') return false; + } + } + // C++ anonymous namespace: namespace_definition with no name child = internal linkage + if (cur.type === 'namespace_definition') { + const hasName = cur.childForFieldName?.('name'); + if (!hasName) return false; + } + cur = cur.parent; + } + return true; // Top-level C/C++ functions default to external linkage +}; + +/** PHP: check for visibility modifier or top-level scope. */ +const phpExportChecker: ExportChecker = (node, _name) => { + let current: SyntaxNode | null = node; + while (current) { + if (current.type === 'class_declaration' || + current.type === 'interface_declaration' || + current.type === 'trait_declaration' || + current.type === 'enum_declaration') { + return true; + } + if (current.type === 'visibility_modifier') { + return current.text === 'public'; + } + current = current.parent; + } + // Top-level functions are globally accessible + return true; +}; + +/** Swift: check for 'public' or 'open' access modifiers. */ +const swiftExportChecker: ExportChecker = (node, _name) => { + let current: SyntaxNode | null = node; + while (current) { + if (current.type === 'modifiers' || current.type === 'visibility_modifier') { + const text = current.text || ''; + if (text.includes('public') || text.includes('open')) return true; + } + current = current.parent; + } + return false; +}; + +// ============================================================================ +// Exhaustive dispatch table — satisfies enforces all SupportedLanguages are covered +// ============================================================================ + +const exportCheckers = { + [SupportedLanguages.JavaScript]: tsExportChecker, + [SupportedLanguages.TypeScript]: tsExportChecker, + [SupportedLanguages.Python]: pythonExportChecker, + [SupportedLanguages.Java]: javaExportChecker, + [SupportedLanguages.CSharp]: csharpExportChecker, + [SupportedLanguages.Go]: goExportChecker, + [SupportedLanguages.Rust]: rustExportChecker, + [SupportedLanguages.Kotlin]: kotlinExportChecker, + [SupportedLanguages.C]: cCppExportChecker, + [SupportedLanguages.CPlusPlus]: cCppExportChecker, + [SupportedLanguages.PHP]: phpExportChecker, + [SupportedLanguages.Swift]: swiftExportChecker, + [SupportedLanguages.Ruby]: (_node, _name) => true, +} satisfies Record<SupportedLanguages, ExportChecker>; + +// ============================================================================ +// Public API +// ============================================================================ + +/** + * Check if a tree-sitter node is exported/public in its language. + * @param node - The tree-sitter AST node + * @param name - The symbol name + * @param language - The programming language + * @returns true if the symbol is exported/public + */ +export const isNodeExported = (node: SyntaxNode, name: string, language: SupportedLanguages): boolean => { + const checker = exportCheckers[language]; + if (!checker) return false; + return checker(node, name); +}; diff --git a/gitnexus/src/core/ingestion/filesystem-walker.ts b/gitnexus/src/core/ingestion/filesystem-walker.ts index c7a2e5d47f..05fad9ec18 100644 --- a/gitnexus/src/core/ingestion/filesystem-walker.ts +++ b/gitnexus/src/core/ingestion/filesystem-walker.ts @@ -1,30 +1,46 @@ import fs from 'fs/promises'; import path from 'path'; import { glob } from 'glob'; -import { shouldIgnorePath } from '../../config/ignore-service.js'; +import { createIgnoreFilter } from '../../config/ignore-service.js'; export interface FileEntry { path: string; content: string; } +/** Lightweight entry — path + size from stat, no content in memory */ +export interface ScannedFile { + path: string; + size: number; +} + +/** Path-only reference (for type signatures) */ +export interface FilePath { + path: string; +} + const READ_CONCURRENCY = 32; /** Skip files larger than 512KB — they're usually generated/vendored and crash tree-sitter */ const MAX_FILE_SIZE = 512 * 1024; -export const walkRepository = async ( +/** + * Phase 1: Scan repository — stat files to get paths + sizes, no content loaded. + * Memory: ~10MB for 100K files vs ~1GB+ with content. + */ +export const walkRepositoryPaths = async ( repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void -): Promise<FileEntry[]> => { - const files = await glob('**/*', { +): Promise<ScannedFile[]> => { + const ignoreFilter = await createIgnoreFilter(repoPath); + + const filtered = await glob('**/*', { cwd: repoPath, nodir: true, dot: false, + ignore: ignoreFilter, }); - - const filtered = files.filter(file => !shouldIgnorePath(file)); - const entries: FileEntry[] = []; + const entries: ScannedFile[] = []; let processed = 0; let skippedLarge = 0; @@ -38,8 +54,7 @@ export const walkRepository = async ( skippedLarge++; return null; } - const content = await fs.readFile(fullPath, 'utf-8'); - return { path: relativePath.replace(/\\/g, '/'), content }; + return { path: relativePath.replace(/\\/g, '/'), size: stat.size }; }) ); @@ -55,8 +70,53 @@ export const walkRepository = async ( } if (skippedLarge > 0) { - console.warn(` Skipped ${skippedLarge} files larger than ${MAX_FILE_SIZE / 1024}KB`); + console.warn(` Skipped ${skippedLarge} large files (>${MAX_FILE_SIZE / 1024}KB, likely generated/vendored)`); } return entries; }; + +/** + * Phase 2: Read file contents for a specific set of relative paths. + * Returns a Map for O(1) lookup. Silently skips files that fail to read. + */ +export const readFileContents = async ( + repoPath: string, + relativePaths: string[], +): Promise<Map<string, string>> => { + const contents = new Map<string, string>(); + + for (let start = 0; start < relativePaths.length; start += READ_CONCURRENCY) { + const batch = relativePaths.slice(start, start + READ_CONCURRENCY); + const results = await Promise.allSettled( + batch.map(async relativePath => { + const fullPath = path.join(repoPath, relativePath); + const content = await fs.readFile(fullPath, 'utf-8'); + return { path: relativePath, content }; + }) + ); + + for (const result of results) { + if (result.status === 'fulfilled') { + contents.set(result.value.path, result.value.content); + } + } + } + + return contents; +}; + +/** + * Legacy API — scans and reads everything into memory. + * Used by sequential fallback path only. + */ +export const walkRepository = async ( + repoPath: string, + onProgress?: (current: number, total: number, filePath: string) => void +): Promise<FileEntry[]> => { + const scanned = await walkRepositoryPaths(repoPath, onProgress); + const contents = await readFileContents(repoPath, scanned.map(f => f.path)); + return scanned + .filter(f => contents.has(f.path)) + .map(f => ({ path: f.path, content: contents.get(f.path)! })); +}; diff --git a/gitnexus/src/core/ingestion/framework-detection.ts b/gitnexus/src/core/ingestion/framework-detection.ts index d3c75ab876..f17d93b361 100644 --- a/gitnexus/src/core/ingestion/framework-detection.ts +++ b/gitnexus/src/core/ingestion/framework-detection.ts @@ -1,8 +1,10 @@ /** * Framework Detection * - * Detects frameworks from file path patterns and provides entry point multipliers. - * This enables framework-aware entry point scoring. + * Detects frameworks from: + * 1) file path patterns + * 2) AST definition text (decorators/annotations/attributes) + * and provides entry point multipliers for process scoring. * * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier * (no bonus, no penalty) - same behavior as before this feature. @@ -127,6 +129,49 @@ export function detectFrameworkFromPath(filePath: string): FrameworkHint | null return { framework: 'java-service', entryPointMultiplier: 1.8, reason: 'java-service' }; } + // ========== KOTLIN FRAMEWORKS ========== + + // Spring Boot Kotlin controllers + if ((p.includes('/controller/') || p.includes('/controllers/')) && p.endsWith('.kt')) { + return { framework: 'spring-kotlin', entryPointMultiplier: 3.0, reason: 'spring-kotlin-controller' }; + } + + // Spring Boot - files ending in Controller.kt + if (p.endsWith('controller.kt')) { + return { framework: 'spring-kotlin', entryPointMultiplier: 3.0, reason: 'spring-kotlin-controller-file' }; + } + + // Ktor routes + if (p.includes('/routes/') && p.endsWith('.kt')) { + return { framework: 'ktor', entryPointMultiplier: 2.5, reason: 'ktor-routes' }; + } + + // Ktor plugins folder or Routing.kt files + if (p.includes('/plugins/') && p.endsWith('.kt')) { + return { framework: 'ktor', entryPointMultiplier: 2.0, reason: 'ktor-plugin' }; + } + if (p.endsWith('routing.kt') || p.endsWith('routes.kt')) { + return { framework: 'ktor', entryPointMultiplier: 2.5, reason: 'ktor-routing-file' }; + } + + // Android Activities, Fragments + if ((p.includes('/activity/') || p.includes('/ui/')) && p.endsWith('.kt')) { + return { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-ui' }; + } + if (p.endsWith('activity.kt') || p.endsWith('fragment.kt')) { + return { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-component' }; + } + + // Kotlin main entry point + if (p.endsWith('/main.kt')) { + return { framework: 'kotlin', entryPointMultiplier: 3.0, reason: 'kotlin-main' }; + } + + // Kotlin Application entry point (common naming) + if (p.endsWith('/application.kt')) { + return { framework: 'kotlin', entryPointMultiplier: 2.5, reason: 'kotlin-application' }; + } + // ========== C# / .NET FRAMEWORKS ========== // ASP.NET Controllers @@ -138,7 +183,35 @@ export function detectFrameworkFromPath(filePath: string): FrameworkHint | null if (p.endsWith('controller.cs')) { return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-controller-file' }; } - + + // ASP.NET Services + if ((p.includes('/services/') || p.includes('/service/')) && p.endsWith('.cs')) { + return { framework: 'aspnet', entryPointMultiplier: 1.8, reason: 'aspnet-service' }; + } + + // ASP.NET Middleware + if (p.includes('/middleware/') && p.endsWith('.cs')) { + return { framework: 'aspnet', entryPointMultiplier: 2.5, reason: 'aspnet-middleware' }; + } + + // SignalR Hubs + if (p.includes('/hubs/') && p.endsWith('.cs')) { + return { framework: 'signalr', entryPointMultiplier: 2.5, reason: 'signalr-hub' }; + } + if (p.endsWith('hub.cs')) { + return { framework: 'signalr', entryPointMultiplier: 2.5, reason: 'signalr-hub-file' }; + } + + // Minimal API / Program.cs / Startup.cs + if (p.endsWith('/program.cs') || p.endsWith('/startup.cs')) { + return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-entry' }; + } + + // Background services / Hosted services + if ((p.includes('/backgroundservices/') || p.includes('/hostedservices/')) && p.endsWith('.cs')) { + return { framework: 'aspnet', entryPointMultiplier: 2.0, reason: 'aspnet-background-service' }; + } + // Blazor pages if (p.includes('/pages/') && p.endsWith('.razor')) { return { framework: 'blazor', entryPointMultiplier: 2.5, reason: 'blazor-page' }; @@ -195,8 +268,129 @@ export function detectFrameworkFromPath(filePath: string): FrameworkHint | null return { framework: 'c-cpp', entryPointMultiplier: 2.5, reason: 'c-app' }; } - // ========== GENERIC PATTERNS ========== + // ========== PHP / LARAVEL FRAMEWORKS ========== + + // Laravel routes (highest - these ARE the entry point definitions) + if (p.includes('/routes/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-routes' }; + } + + // Laravel controllers (very high - receive HTTP requests) + if ((p.includes('/http/controllers/') || p.includes('/controllers/')) && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller' }; + } + + // Laravel controller by file name convention + if (p.endsWith('controller.php')) { + return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller-file' }; + } + + // Laravel console commands + if ((p.includes('/console/commands/') || p.includes('/commands/')) && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-command' }; + } + + // Laravel jobs (queue entry points) + if (p.includes('/jobs/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-job' }; + } + + // Laravel listeners (event-driven entry points) + if (p.includes('/listeners/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-listener' }; + } + + // Laravel middleware + if (p.includes('/http/middleware/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-middleware' }; + } + + // Laravel service providers + if (p.includes('/providers/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-provider' }; + } + + // Laravel policies + if (p.includes('/policies/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 2.0, reason: 'laravel-policy' }; + } + + // Laravel models (important but not entry points per se) + if (p.includes('/models/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-model' }; + } + + // Laravel services (Service Repository pattern) + if (p.includes('/services/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-service' }; + } + + // Laravel repositories (Service Repository pattern) + if (p.includes('/repositories/') && p.endsWith('.php')) { + return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-repository' }; + } + + // ========== RUBY ========== + + // Ruby: bin/ or exe/ (CLI entry points) + if ((p.includes('/bin/') || p.includes('/exe/')) && p.endsWith('.rb')) { + return { framework: 'ruby', entryPointMultiplier: 2.5, reason: 'ruby-executable' }; + } + + // Ruby: Rakefile or *.rake (task definitions) + if (p.endsWith('/rakefile') || p.endsWith('.rake')) { + return { framework: 'ruby', entryPointMultiplier: 1.5, reason: 'ruby-rake' }; + } + // ========== SWIFT / iOS ========== + + // iOS App entry points (highest priority) + if (p.endsWith('/appdelegate.swift') || p.endsWith('/scenedelegate.swift') || p.endsWith('/app.swift')) { + return { framework: 'ios', entryPointMultiplier: 3.0, reason: 'ios-app-entry' }; + } + + // SwiftUI App entry (@main) + if (p.endsWith('app.swift') && p.includes('/sources/')) { + return { framework: 'swiftui', entryPointMultiplier: 3.0, reason: 'swiftui-app' }; + } + + // UIKit ViewControllers (high priority - screen entry points) + if ((p.includes('/viewcontrollers/') || p.includes('/controllers/') || p.includes('/screens/')) && p.endsWith('.swift')) { + return { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-viewcontroller' }; + } + + // ViewController by filename convention + if (p.endsWith('viewcontroller.swift') || p.endsWith('vc.swift')) { + return { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-viewcontroller-file' }; + } + + // Coordinator pattern (navigation entry points) + if (p.includes('/coordinators/') && p.endsWith('.swift')) { + return { framework: 'ios-coordinator', entryPointMultiplier: 2.5, reason: 'ios-coordinator' }; + } + + // Coordinator by filename + if (p.endsWith('coordinator.swift')) { + return { framework: 'ios-coordinator', entryPointMultiplier: 2.5, reason: 'ios-coordinator-file' }; + } + + // SwiftUI Views (moderate - reusable components) + if ((p.includes('/views/') || p.includes('/scenes/')) && p.endsWith('.swift')) { + return { framework: 'swiftui', entryPointMultiplier: 1.8, reason: 'swiftui-view' }; + } + + // Service layer + if (p.includes('/services/') && p.endsWith('.swift')) { + return { framework: 'ios-service', entryPointMultiplier: 1.8, reason: 'ios-service' }; + } + + // Router / navigation + if (p.includes('/router/') && p.endsWith('.swift')) { + return { framework: 'ios-router', entryPointMultiplier: 2.0, reason: 'ios-router' }; + } + + // ========== GENERIC PATTERNS ========== + // Any language: index files in API folders if (p.includes('/api/') && ( p.endsWith('/index.ts') || p.endsWith('/index.js') || @@ -210,12 +404,12 @@ export function detectFrameworkFromPath(filePath: string): FrameworkHint | null } // ============================================================================ -// FUTURE: AST-BASED PATTERNS (for Phase 3) +// AST-BASED FRAMEWORK DETECTION // ============================================================================ /** - * Patterns that indicate entry points within code (for future AST-based detection) - * These would require parsing decorators/annotations in the code itself. + * Patterns that indicate framework entry points within code definitions. + * These are matched against AST node text (class/method/function declaration text). */ export const FRAMEWORK_AST_PATTERNS = { // JavaScript/TypeScript decorators @@ -231,13 +425,107 @@ export const FRAMEWORK_AST_PATTERNS = { 'jaxrs': ['@Path', '@GET', '@POST', '@PUT', '@DELETE'], // C# attributes - 'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[Route]'], + 'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[HttpPut]', '[HttpDelete]', + '[Route]', '[Authorize]', '[AllowAnonymous]'], + 'signalr': ['[HubMethodName]', ': Hub', ': Hub<'], + 'blazor': ['@page', '[Parameter]', '@inject'], + 'efcore': ['DbContext', 'DbSet<', 'OnModelCreating'], // Go patterns (function signatures) 'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP'], - + + // PHP/Laravel + 'laravel': ['Route::get', 'Route::post', 'Route::put', 'Route::delete', + 'Route::resource', 'Route::apiResource', '#[Route('], + // Rust macros 'actix': ['#[get', '#[post', '#[put', '#[delete'], 'axum': ['Router::new'], 'rocket': ['#[get', '#[post'], + + // Swift/iOS + 'uikit': ['viewDidLoad', 'viewWillAppear', 'viewDidAppear', 'UIViewController'], + 'swiftui': ['@main', 'WindowGroup', 'ContentView', '@StateObject', '@ObservedObject'], + 'combine': ['sink', 'assign', 'Publisher', 'Subscriber'], }; + +import { SupportedLanguages } from '../../config/supported-languages.js'; + +interface AstFrameworkPatternConfig { + framework: string; + entryPointMultiplier: number; + reason: string; + patterns: string[]; +} + +const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE: Record<string, AstFrameworkPatternConfig[]> = { + [SupportedLanguages.JavaScript]: [ + { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs }, + ], + [SupportedLanguages.TypeScript]: [ + { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs }, + ], + [SupportedLanguages.Python]: [ + { framework: 'fastapi', entryPointMultiplier: 3.0, reason: 'fastapi-decorator', patterns: FRAMEWORK_AST_PATTERNS.fastapi }, + { framework: 'flask', entryPointMultiplier: 2.8, reason: 'flask-decorator', patterns: FRAMEWORK_AST_PATTERNS.flask }, + ], + [SupportedLanguages.Java]: [ + { framework: 'spring', entryPointMultiplier: 3.2, reason: 'spring-annotation', patterns: FRAMEWORK_AST_PATTERNS.spring }, + { framework: 'jaxrs', entryPointMultiplier: 3.0, reason: 'jaxrs-annotation', patterns: FRAMEWORK_AST_PATTERNS.jaxrs }, + ], + [SupportedLanguages.Kotlin]: [ + { framework: 'spring-kotlin', entryPointMultiplier: 3.2, reason: 'spring-kotlin-annotation', patterns: FRAMEWORK_AST_PATTERNS.spring }, + { framework: 'jaxrs', entryPointMultiplier: 3.0, reason: 'jaxrs-annotation', patterns: FRAMEWORK_AST_PATTERNS.jaxrs }, + { framework: 'ktor', entryPointMultiplier: 2.8, reason: 'ktor-routing', patterns: ['routing', 'embeddedServer', 'Application.module'] }, + { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-annotation', patterns: ['@AndroidEntryPoint', 'AppCompatActivity', 'Fragment('] }, + ], + [SupportedLanguages.CSharp]: [ + { framework: 'aspnet', entryPointMultiplier: 3.2, reason: 'aspnet-attribute', patterns: FRAMEWORK_AST_PATTERNS.aspnet }, + { framework: 'signalr', entryPointMultiplier: 2.8, reason: 'signalr-attribute', patterns: FRAMEWORK_AST_PATTERNS.signalr }, + { framework: 'blazor', entryPointMultiplier: 2.5, reason: 'blazor-attribute', patterns: FRAMEWORK_AST_PATTERNS.blazor }, + { framework: 'efcore', entryPointMultiplier: 2.0, reason: 'efcore-pattern', patterns: FRAMEWORK_AST_PATTERNS.efcore }, + ], + [SupportedLanguages.PHP]: [ + { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'php-route-attribute', patterns: FRAMEWORK_AST_PATTERNS.laravel }, + ], +}; + +/** Pre-lowercased patterns for O(1) pattern matching at runtime */ +const AST_PATTERNS_LOWERED: Record<string, Array<{ framework: string; entryPointMultiplier: number; reason: string; patterns: string[] }>> = + Object.fromEntries( + Object.entries(AST_FRAMEWORK_PATTERNS_BY_LANGUAGE).map(([lang, cfgs]) => [ + lang, + cfgs.map(cfg => ({ ...cfg, patterns: cfg.patterns.map(p => p.toLowerCase()) })), + ]) + ); + +/** + * Detect framework entry points from AST definition text (decorators/annotations/attributes). + * Returns null if no known pattern is found. + * Note: callers should slice definitionText to ~300 chars since annotations appear at the start. + */ +export function detectFrameworkFromAST( + language: SupportedLanguages, + definitionText: string +): FrameworkHint | null { + if (!language || !definitionText) return null; + + const configs = AST_PATTERNS_LOWERED[language.toLowerCase()]; + if (!configs || configs.length === 0) return null; + + const normalized = definitionText.toLowerCase(); + + for (const cfg of configs) { + for (const pattern of cfg.patterns) { + if (normalized.includes(pattern)) { + return { + framework: cfg.framework, + entryPointMultiplier: cfg.entryPointMultiplier, + reason: cfg.reason, + }; + } + } + } + + return null; +} diff --git a/gitnexus/src/core/ingestion/heritage-processor.ts b/gitnexus/src/core/ingestion/heritage-processor.ts index dbb7bac8ca..cbbff44305 100644 --- a/gitnexus/src/core/ingestion/heritage-processor.ts +++ b/gitnexus/src/core/ingestion/heritage-processor.ts @@ -1,29 +1,99 @@ /** * Heritage Processor - * + * * Extracts class inheritance relationships: - * - EXTENDS: Class extends another Class (TS, JS, Python) - * - IMPLEMENTS: Class implements an Interface (TS only) + * - EXTENDS: Class extends another Class (TS, JS, Python, C#, C++) + * - IMPLEMENTS: Class implements an Interface (TS, C#, Java, Kotlin, PHP) + * + * Languages like C# use a single `base_list` for both class and interface parents. + * We resolve the correct edge type by checking the symbol table: if the parent is + * registered as an Interface, we emit IMPLEMENTS; otherwise EXTENDS. For unresolved + * external symbols, the fallback heuristic is language-gated: + * - C# / Java: apply the `I[A-Z]` naming convention (e.g. IDisposable → IMPLEMENTS) + * - Swift: default to IMPLEMENTS (protocol conformance is more common than class inheritance) + * - All other languages: default to EXTENDS */ import { KnowledgeGraph } from '../graph/types.js'; import { ASTCache } from './ast-cache.js'; -import { SymbolTable } from './symbol-table.js'; import Parser from 'tree-sitter'; -import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js'; +import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js'; import { LANGUAGE_QUERIES } from './tree-sitter-queries.js'; import { generateId } from '../../lib/utils.js'; -import { getLanguageFromFilename, yieldToEventLoop } from './utils.js'; +import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js'; +import { SupportedLanguages } from '../../config/supported-languages.js'; +import { getTreeSitterBufferSize } from './constants.js'; import type { ExtractedHeritage } from './workers/parse-worker.js'; +import type { ResolutionContext } from './resolution-context.js'; + +/** C#/Java convention: interfaces start with I followed by an uppercase letter */ +const INTERFACE_NAME_RE = /^I[A-Z]/; + +/** + * Determine whether a heritage.extends capture is actually an IMPLEMENTS relationship. + * Uses the symbol table first (authoritative — Tier 1); falls back to a language-gated + * heuristic for external symbols not present in the graph: + * - C# / Java: `I[A-Z]` naming convention + * - Swift: default IMPLEMENTS (protocol conformance is the norm) + * - All others: default EXTENDS + */ +const resolveExtendsType = ( + parentName: string, + currentFilePath: string, + ctx: ResolutionContext, + language: SupportedLanguages, +): { type: 'EXTENDS' | 'IMPLEMENTS'; idPrefix: string } => { + const resolved = ctx.resolve(parentName, currentFilePath); + if (resolved && resolved.candidates.length > 0) { + const isInterface = resolved.candidates[0].type === 'Interface'; + return isInterface + ? { type: 'IMPLEMENTS', idPrefix: 'Interface' } + : { type: 'EXTENDS', idPrefix: 'Class' }; + } + // Unresolved symbol — fall back to language-specific heuristic + if (language === SupportedLanguages.CSharp || language === SupportedLanguages.Java) { + if (INTERFACE_NAME_RE.test(parentName)) { + return { type: 'IMPLEMENTS', idPrefix: 'Interface' }; + } + } else if (language === SupportedLanguages.Swift) { + // Protocol conformance is far more common than class inheritance in Swift + return { type: 'IMPLEMENTS', idPrefix: 'Interface' }; + } + return { type: 'EXTENDS', idPrefix: 'Class' }; +}; + +/** + * Resolve a symbol ID for heritage, with fallback to generated ID. + * Uses ctx.resolve() → pick first candidate's nodeId → generate synthetic ID. + */ +const resolveHeritageId = ( + name: string, + filePath: string, + ctx: ResolutionContext, + fallbackLabel: string, + fallbackKey?: string, +): string => { + const resolved = ctx.resolve(name, filePath); + if (resolved && resolved.candidates.length > 0) { + // For global with multiple candidates, refuse (a wrong edge is worse than no edge) + if (resolved.tier === 'global' && resolved.candidates.length > 1) { + return generateId(fallbackLabel, fallbackKey ?? name); + } + return resolved.candidates[0].nodeId; + } + return generateId(fallbackLabel, fallbackKey ?? name); +}; export const processHeritage = async ( graph: KnowledgeGraph, files: { path: string; content: string }[], astCache: ASTCache, - symbolTable: SymbolTable, - onProgress?: (current: number, total: number) => void + ctx: ResolutionContext, + onProgress?: (current: number, total: number) => void, ) => { const parser = await loadParser(); + const logSkipped = isVerboseIngestionEnabled(); + const skippedByLang = logSkipped ? new Map<string, number>() : null; for (let i = 0; i < files.length; i++) { const file = files[i]; @@ -33,6 +103,12 @@ export const processHeritage = async ( // 1. Check language support const language = getLanguageFromFilename(file.path); if (!language) continue; + if (!isLanguageAvailable(language)) { + if (skippedByLang) { + skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1); + } + continue; + } const queryStr = LANGUAGE_QUERIES[language]; if (!queryStr) continue; @@ -42,17 +118,14 @@ export const processHeritage = async ( // 3. Get AST let tree = astCache.get(file.path); - let wasReparsed = false; - if (!tree) { // Use larger bufferSize for files > 32KB try { - tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 }); + tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) }); } catch (parseError) { // Skip files that can't be parsed continue; } - wasReparsed = true; // Cache re-parsed tree for potential future use astCache.set(file.path, tree); } @@ -75,27 +148,30 @@ export const processHeritage = async ( captureMap[c.name] = c.node; }); - // EXTENDS: Class extends another Class + // EXTENDS or IMPLEMENTS: resolve via symbol table for languages where + // the tree-sitter query can't distinguish classes from interfaces (C#, Java) if (captureMap['heritage.class'] && captureMap['heritage.extends']) { + // Go struct embedding: skip named fields (only anonymous fields are embedded) + const extendsNode = captureMap['heritage.extends']; + const fieldDecl = extendsNode.parent; + if (fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name')) { + return; // Named field, not struct embedding + } + const className = captureMap['heritage.class'].text; const parentClassName = captureMap['heritage.extends'].text; - // Resolve both class IDs - const childId = symbolTable.lookupExact(file.path, className) || - symbolTable.lookupFuzzy(className)[0]?.nodeId || - generateId('Class', `${file.path}:${className}`); - - const parentId = symbolTable.lookupFuzzy(parentClassName)[0]?.nodeId || - generateId('Class', `${parentClassName}`); + const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, ctx, language); + + const childId = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`); + const parentId = resolveHeritageId(parentClassName, file.path, ctx, idPrefix); if (childId && parentId && childId !== parentId) { - const relId = generateId('EXTENDS', `${childId}->${parentId}`); - graph.addRelationship({ - id: relId, + id: generateId(relType, `${childId}->${parentId}`), sourceId: childId, targetId: parentId, - type: 'EXTENDS', + type: relType, confidence: 1.0, reason: '', }); @@ -107,19 +183,12 @@ export const processHeritage = async ( const className = captureMap['heritage.class'].text; const interfaceName = captureMap['heritage.implements'].text; - // Resolve class and interface IDs - const classId = symbolTable.lookupExact(file.path, className) || - symbolTable.lookupFuzzy(className)[0]?.nodeId || - generateId('Class', `${file.path}:${className}`); - - const interfaceId = symbolTable.lookupFuzzy(interfaceName)[0]?.nodeId || - generateId('Interface', `${interfaceName}`); + const classId = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`); + const interfaceId = resolveHeritageId(interfaceName, file.path, ctx, 'Interface'); if (classId && interfaceId) { - const relId = generateId('IMPLEMENTS', `${classId}->${interfaceId}`); - graph.addRelationship({ - id: relId, + id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`), sourceId: classId, targetId: interfaceId, type: 'IMPLEMENTS', @@ -134,19 +203,12 @@ export const processHeritage = async ( const structName = captureMap['heritage.class'].text; const traitName = captureMap['heritage.trait'].text; - // Resolve struct and trait IDs - const structId = symbolTable.lookupExact(file.path, structName) || - symbolTable.lookupFuzzy(structName)[0]?.nodeId || - generateId('Struct', `${file.path}:${structName}`); - - const traitId = symbolTable.lookupFuzzy(traitName)[0]?.nodeId || - generateId('Trait', `${traitName}`); + const structId = resolveHeritageId(structName, file.path, ctx, 'Struct', `${file.path}:${structName}`); + const traitId = resolveHeritageId(traitName, file.path, ctx, 'Trait'); if (structId && traitId) { - const relId = generateId('IMPLEMENTS', `${structId}->${traitId}`); - graph.addRelationship({ - id: relId, + id: generateId('IMPLEMENTS', `${structId}->${traitId}`), sourceId: structId, targetId: traitId, type: 'IMPLEMENTS', @@ -159,6 +221,14 @@ export const processHeritage = async ( // Tree is now owned by the LRU cache — no manual delete needed } + + if (skippedByLang && skippedByLang.size > 0) { + for (const [lang, count] of skippedByLang.entries()) { + console.warn( + `[ingestion] Skipped ${count} ${lang} file(s) in heritage processing — ${lang} parser not available.` + ); + } + } }; /** @@ -168,8 +238,8 @@ export const processHeritage = async ( export const processHeritageFromExtracted = async ( graph: KnowledgeGraph, extractedHeritage: ExtractedHeritage[], - symbolTable: SymbolTable, - onProgress?: (current: number, total: number) => void + ctx: ResolutionContext, + onProgress?: (current: number, total: number) => void, ) => { const total = extractedHeritage.length; @@ -182,30 +252,26 @@ export const processHeritageFromExtracted = async ( const h = extractedHeritage[i]; if (h.kind === 'extends') { - const childId = symbolTable.lookupExact(h.filePath, h.className) || - symbolTable.lookupFuzzy(h.className)[0]?.nodeId || - generateId('Class', `${h.filePath}:${h.className}`); + const fileLanguage = getLanguageFromFilename(h.filePath); + if (!fileLanguage) continue; + const { type: relType, idPrefix } = resolveExtendsType(h.parentName, h.filePath, ctx, fileLanguage); - const parentId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId || - generateId('Class', `${h.parentName}`); + const childId = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`); + const parentId = resolveHeritageId(h.parentName, h.filePath, ctx, idPrefix); if (childId && parentId && childId !== parentId) { graph.addRelationship({ - id: generateId('EXTENDS', `${childId}->${parentId}`), + id: generateId(relType, `${childId}->${parentId}`), sourceId: childId, targetId: parentId, - type: 'EXTENDS', + type: relType, confidence: 1.0, reason: '', }); } } else if (h.kind === 'implements') { - const classId = symbolTable.lookupExact(h.filePath, h.className) || - symbolTable.lookupFuzzy(h.className)[0]?.nodeId || - generateId('Class', `${h.filePath}:${h.className}`); - - const interfaceId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId || - generateId('Interface', `${h.parentName}`); + const classId = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`); + const interfaceId = resolveHeritageId(h.parentName, h.filePath, ctx, 'Interface'); if (classId && interfaceId) { graph.addRelationship({ @@ -217,22 +283,18 @@ export const processHeritageFromExtracted = async ( reason: '', }); } - } else if (h.kind === 'trait-impl') { - const structId = symbolTable.lookupExact(h.filePath, h.className) || - symbolTable.lookupFuzzy(h.className)[0]?.nodeId || - generateId('Struct', `${h.filePath}:${h.className}`); - - const traitId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId || - generateId('Trait', `${h.parentName}`); + } else if (h.kind === 'trait-impl' || h.kind === 'include' || h.kind === 'extend' || h.kind === 'prepend') { + const structId = resolveHeritageId(h.className, h.filePath, ctx, 'Struct', `${h.filePath}:${h.className}`); + const traitId = resolveHeritageId(h.parentName, h.filePath, ctx, 'Trait'); if (structId && traitId) { graph.addRelationship({ - id: generateId('IMPLEMENTS', `${structId}->${traitId}`), + id: generateId('IMPLEMENTS', `${structId}->${traitId}:${h.kind}`), sourceId: structId, targetId: traitId, type: 'IMPLEMENTS', confidence: 1.0, - reason: 'trait-impl', + reason: h.kind, }); } } diff --git a/gitnexus/src/core/ingestion/import-processor.ts b/gitnexus/src/core/ingestion/import-processor.ts index 54b5ea0709..8a1e3ca41c 100644 --- a/gitnexus/src/core/ingestion/import-processor.ts +++ b/gitnexus/src/core/ingestion/import-processor.ts @@ -1,14 +1,56 @@ -import fs from 'fs/promises'; -import path from 'path'; import { KnowledgeGraph } from '../graph/types.js'; import { ASTCache } from './ast-cache.js'; import Parser from 'tree-sitter'; -import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js'; +import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js'; import { LANGUAGE_QUERIES } from './tree-sitter-queries.js'; import { generateId } from '../../lib/utils.js'; -import { getLanguageFromFilename, yieldToEventLoop } from './utils.js'; +import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js'; import { SupportedLanguages } from '../../config/supported-languages.js'; +import { extractNamedBindings } from './named-binding-extraction.js'; import type { ExtractedImport } from './workers/parse-worker.js'; +import { getTreeSitterBufferSize } from './constants.js'; +import { + loadTsconfigPaths, + loadGoModulePath, + loadComposerConfig, + loadCSharpProjectConfig, + loadSwiftPackageConfig, + type SwiftPackageConfig, +} from './language-config.js'; +import { + buildSuffixIndex, + resolveImportPath, + appendKotlinWildcard, + KOTLIN_EXTENSIONS, + resolveJvmWildcard, + resolveJvmMemberImport, + resolveGoPackageDir, + resolveGoPackage, + resolveCSharpImport, + resolveCSharpNamespaceDir, + resolvePhpImport, + resolveRustImport, + resolveRubyImport, + resolvePythonImport, +} from './resolvers/index.js'; +import { callRouters } from './call-routing.js'; +import type { ResolutionContext } from './resolution-context.js'; +import type { + SuffixIndex, + TsconfigPaths, + GoModuleConfig, + CSharpProjectConfig, + ComposerConfig +} from './resolvers/index.js'; + +// Re-export resolver types for consumers +export type { + SuffixIndex, + TsconfigPaths, + GoModuleConfig, + CSharpProjectConfig, + ComposerConfig +} from './resolvers/index.js'; const isDev = process.env.NODE_ENV === 'development'; @@ -16,539 +58,251 @@ const isDev = process.env.NODE_ENV === 'development'; // Stores all files that a given file imports from export type ImportMap = Map<string, Set<string>>; -export const createImportMap = (): ImportMap => new Map(); +// Type: Map<FilePath, Set<PackageDirSuffix>> +// Stores Go package directory suffixes imported by a file (e.g., "/internal/auth/"). +// Avoids expanding every Go package import into N individual ImportMap edges. +export type PackageMap = Map<string, Set<string>>; + +// Type: Map<ImportingFilePath, Map<LocalName, {sourcePath, exportedName}>> +// Tracks which specific names a file imports from which sources (TS/Python only). +// Used to tighten Tier 2a resolution: `import { User } from './models'` +// means only `User` (not `Repo`) is visible from models.ts via this import. +// Stores both the resolved source path and the original exported name so that +// aliased imports (`import { User as U }`) can resolve U → User in the source file. +export interface NamedImportBinding { sourcePath: string; exportedName: string } +export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>; + +/** + * Check if a file path is directly inside a package directory identified by its suffix. + * Used by the symbol resolver for Go and C# directory-level import matching. + */ +export function isFileInPackageDir(filePath: string, dirSuffix: string): boolean { + // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/" + const normalized = '/' + filePath.replace(/\\/g, '/'); + if (!normalized.includes(dirSuffix)) return false; + const afterDir = normalized.substring(normalized.indexOf(dirSuffix) + dirSuffix.length); + return !afterDir.includes('/'); +} + +/** Pre-built lookup structures for import resolution. Build once, reuse across chunks. */ +export interface ImportResolutionContext { + allFilePaths: Set<string>; + allFileList: string[]; + normalizedFileList: string[]; + suffixIndex: SuffixIndex; + resolveCache: Map<string, string | null>; +} + +export function buildImportResolutionContext(allPaths: string[]): ImportResolutionContext { + const allFileList = allPaths; + const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/')); + const allFilePaths = new Set(allFileList); + const suffixIndex = buildSuffixIndex(normalizedFileList, allFileList); + return { allFilePaths, allFileList, normalizedFileList, suffixIndex, resolveCache: new Map() }; +} + +// Config loaders extracted to ./language-config.ts (Phase 2 refactor) +// Resolver functions are in ./resolvers/ — imported above // ============================================================================ -// LANGUAGE-SPECIFIC CONFIG +// SHARED LANGUAGE DISPATCH // ============================================================================ -/** TypeScript path alias config parsed from tsconfig.json */ -interface TsconfigPaths { - /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */ - aliases: Map<string, string>; - /** Base URL for path resolution (relative to repo root) */ - baseUrl: string; +/** Bundled language-specific configs loaded once per ingestion run. */ +interface LanguageConfigs { + tsconfigPaths: TsconfigPaths | null; + goModule: GoModuleConfig | null; + composerConfig: ComposerConfig | null; + swiftPackageConfig: SwiftPackageConfig | null; + csharpConfigs: CSharpProjectConfig[]; } -/** Go module config parsed from go.mod */ -interface GoModuleConfig { - /** Module path (e.g., "github.com/user/repo") */ - modulePath: string; +/** Context for import path resolution (file lists, indexes, cache). */ +interface ResolveCtx { + allFilePaths: Set<string>; + allFileList: string[]; + normalizedFileList: string[]; + index: SuffixIndex; + resolveCache: Map<string, string | null>; } /** - * Parse tsconfig.json to extract path aliases. - * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order. + * Result of resolving an import via language-specific dispatch. + * - 'files': resolved to one or more files → add to ImportMap + * - 'package': resolved to a directory → add graph edges + store dirSuffix in PackageMap + * - null: no resolution (external dependency, etc.) */ -async function loadTsconfigPaths(repoRoot: string): Promise<TsconfigPaths | null> { - const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json']; - - for (const filename of candidates) { - try { - const tsconfigPath = path.join(repoRoot, filename); - const raw = await fs.readFile(tsconfigPath, 'utf-8'); - // Strip JSON comments (// and /* */ style) for robustness - const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, ''); - const tsconfig = JSON.parse(stripped); - const compilerOptions = tsconfig.compilerOptions; - if (!compilerOptions?.paths) continue; - - const baseUrl = compilerOptions.baseUrl || '.'; - const aliases = new Map<string, string>(); - - for (const [pattern, targets] of Object.entries(compilerOptions.paths)) { - if (!Array.isArray(targets) || targets.length === 0) continue; - const target = targets[0] as string; - - // Convert glob patterns: "@/*" -> "@/", "src/*" -> "src/" - const aliasPrefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern; - const targetPrefix = target.endsWith('/*') ? target.slice(0, -1) : target; - - aliases.set(aliasPrefix, targetPrefix); - } - - if (aliases.size > 0) { - if (isDev) { - console.log(`📦 Loaded ${aliases.size} path aliases from ${filename}`); - } - return { aliases, baseUrl }; - } - } catch { - // File doesn't exist or isn't valid JSON - try next - } - } - - return null; -} +type ImportResult = + | { kind: 'files'; files: string[] } + | { kind: 'package'; files: string[]; dirSuffix: string } + | null; /** - * Parse go.mod to extract module path. + * Shared language dispatch for import resolution. + * Used by both processImports and processImportsFromExtracted. */ -async function loadGoModulePath(repoRoot: string): Promise<GoModuleConfig | null> { - try { - const goModPath = path.join(repoRoot, 'go.mod'); - const content = await fs.readFile(goModPath, 'utf-8'); - const match = content.match(/^module\s+(\S+)/m); - if (match) { - if (isDev) { - console.log(`📦 Loaded Go module path: ${match[1]}`); - } - return { modulePath: match[1] }; - } - } catch { - // No go.mod - } - return null; -} - -// ============================================================================ -// IMPORT PATH RESOLUTION -// ============================================================================ - -/** All file extensions to try during resolution */ -const EXTENSIONS = [ - '', - // TypeScript/JavaScript - '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js', - // Python - '.py', '/__init__.py', - // Java - '.java', - // C/C++ - '.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.hh', - // C# - '.cs', - // Go - '.go', - // Rust - '.rs', '/mod.rs', -]; - -/** - * Try to match a path (with extensions) against the known file set. - * Returns the matched file path or null. - */ -function tryResolveWithExtensions( - basePath: string, - allFiles: Set<string>, -): string | null { - for (const ext of EXTENSIONS) { - const candidate = basePath + ext; - if (allFiles.has(candidate)) return candidate; - } - return null; -} - -/** - * Build a suffix index for O(1) endsWith lookups. - * Maps every possible path suffix to its original file path. - * e.g. for "src/com/example/Foo.java": - * "Foo.java" -> "src/com/example/Foo.java" - * "example/Foo.java" -> "src/com/example/Foo.java" - * "com/example/Foo.java" -> "src/com/example/Foo.java" - * etc. - */ -export interface SuffixIndex { - /** Exact suffix lookup (case-sensitive) */ - get(suffix: string): string | undefined; - /** Case-insensitive suffix lookup */ - getInsensitive(suffix: string): string | undefined; - /** Get all files in a directory suffix */ - getFilesInDir(dirSuffix: string, extension: string): string[]; -} - -function buildSuffixIndex(normalizedFileList: string[], allFileList: string[]): SuffixIndex { - // Map: normalized suffix -> original file path - const exactMap = new Map<string, string>(); - // Map: lowercase suffix -> original file path - const lowerMap = new Map<string, string>(); - // Map: directory suffix -> list of file paths in that directory - const dirMap = new Map<string, string[]>(); - - for (let i = 0; i < normalizedFileList.length; i++) { - const normalized = normalizedFileList[i]; - const original = allFileList[i]; - const parts = normalized.split('/'); - - // Index all suffixes: "a/b/c.java" -> ["c.java", "b/c.java", "a/b/c.java"] - for (let j = parts.length - 1; j >= 0; j--) { - const suffix = parts.slice(j).join('/'); - // Only store first match (longest path wins for ambiguous suffixes) - if (!exactMap.has(suffix)) { - exactMap.set(suffix, original); - } - const lower = suffix.toLowerCase(); - if (!lowerMap.has(lower)) { - lowerMap.set(lower, original); - } - } - - // Index directory membership - const lastSlash = normalized.lastIndexOf('/'); - if (lastSlash >= 0) { - // Build all directory suffixes - const dirParts = parts.slice(0, -1); - const fileName = parts[parts.length - 1]; - const ext = fileName.substring(fileName.lastIndexOf('.')); - - for (let j = dirParts.length - 1; j >= 0; j--) { - const dirSuffix = dirParts.slice(j).join('/'); - const key = `${dirSuffix}:${ext}`; - let list = dirMap.get(key); - if (!list) { - list = []; - dirMap.set(key, list); - } - list.push(original); - } - } - } - - return { - get: (suffix: string) => exactMap.get(suffix), - getInsensitive: (suffix: string) => lowerMap.get(suffix.toLowerCase()), - getFilesInDir: (dirSuffix: string, extension: string) => { - return dirMap.get(`${dirSuffix}:${extension}`) || []; - }, - }; -} - -/** - * Suffix-based resolution using index. O(1) per lookup instead of O(files). - */ -function suffixResolve( - pathParts: string[], - normalizedFileList: string[], - allFileList: string[], - index?: SuffixIndex, -): string | null { - if (index) { - for (let i = 0; i < pathParts.length; i++) { - const suffix = pathParts.slice(i).join('/'); - for (const ext of EXTENSIONS) { - const suffixWithExt = suffix + ext; - const result = index.get(suffixWithExt) || index.getInsensitive(suffixWithExt); - if (result) return result; - } - } - return null; - } - - // Fallback: linear scan (for backward compatibility) - for (let i = 0; i < pathParts.length; i++) { - const suffix = pathParts.slice(i).join('/'); - for (const ext of EXTENSIONS) { - const suffixWithExt = suffix + ext; - const suffixPattern = '/' + suffixWithExt; - const matchIdx = normalizedFileList.findIndex(filePath => - filePath.endsWith(suffixPattern) || filePath.toLowerCase().endsWith(suffixPattern.toLowerCase()) - ); - if (matchIdx !== -1) { - return allFileList[matchIdx]; - } - } - } - return null; -} - -/** - * Resolve an import path to a file path in the repository. - * - * Language-specific preprocessing is applied before the generic resolution: - * - TypeScript/JavaScript: rewrites tsconfig path aliases - * - Rust: converts crate::/super::/self:: to relative paths - * - * Java wildcards and Go package imports are handled separately in processImports - * because they resolve to multiple files. - */ -const resolveImportPath = ( - currentFile: string, - importPath: string, - allFiles: Set<string>, - allFileList: string[], - normalizedFileList: string[], - resolveCache: Map<string, string | null>, +function resolveLanguageImport( + filePath: string, + rawImportPath: string, language: SupportedLanguages, - tsconfigPaths: TsconfigPaths | null, - index?: SuffixIndex, -): string | null => { - const cacheKey = `${currentFile}::${importPath}`; - if (resolveCache.has(cacheKey)) return resolveCache.get(cacheKey) ?? null; + configs: LanguageConfigs, + ctx: ResolveCtx, +): ImportResult { + const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = ctx; + const { tsconfigPaths, goModule, composerConfig, swiftPackageConfig, csharpConfigs } = configs; - const cache = (result: string | null): string | null => { - resolveCache.set(cacheKey, result); - return result; - }; + // JVM languages (Java + Kotlin): handle wildcards and member imports + if (language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin) { + const exts = language === SupportedLanguages.Java ? ['.java'] : KOTLIN_EXTENSIONS; - // ---- TypeScript/JavaScript: rewrite path aliases ---- - if ( - (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) && - tsconfigPaths && - !importPath.startsWith('.') - ) { - for (const [aliasPrefix, targetPrefix] of tsconfigPaths.aliases) { - if (importPath.startsWith(aliasPrefix)) { - const remainder = importPath.slice(aliasPrefix.length); - // Build the rewritten path relative to baseUrl - const rewritten = tsconfigPaths.baseUrl === '.' - ? targetPrefix + remainder - : tsconfigPaths.baseUrl + '/' + targetPrefix + remainder; + if (rawImportPath.endsWith('.*')) { + const matchedFiles = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, exts, index); + if (matchedFiles.length === 0 && language === SupportedLanguages.Kotlin) { + const javaMatches = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, ['.java'], index); + if (javaMatches.length > 0) return { kind: 'files', files: javaMatches }; + } + if (matchedFiles.length > 0) return { kind: 'files', files: matchedFiles }; + // Fall through to standard resolution + } else { + let memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, exts, index); + if (!memberResolved && language === SupportedLanguages.Kotlin) { + memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, ['.java'], index); + } + if (memberResolved) return { kind: 'files', files: [memberResolved] }; + // Fall through to standard resolution + } + } - // Try direct resolution from repo root - const resolved = tryResolveWithExtensions(rewritten, allFiles); - if (resolved) return cache(resolved); - - // Try suffix matching as fallback - const parts = rewritten.split('/').filter(Boolean); - const suffixResult = suffixResolve(parts, normalizedFileList, allFileList, index); - if (suffixResult) return cache(suffixResult); + // Go: handle package-level imports + if (language === SupportedLanguages.Go && goModule && rawImportPath.startsWith(goModule.modulePath)) { + const pkgSuffix = resolveGoPackageDir(rawImportPath, goModule); + if (pkgSuffix) { + const pkgFiles = resolveGoPackage(rawImportPath, goModule, normalizedFileList, allFileList); + if (pkgFiles.length > 0) { + return { kind: 'package', files: pkgFiles, dirSuffix: pkgSuffix }; } } + // Fall through if no files found (package might be external) } - // ---- Rust: convert module path syntax to file paths ---- - if (language === SupportedLanguages.Rust) { - const rustResult = resolveRustImport(currentFile, importPath, allFiles); - if (rustResult) return cache(rustResult); - // Fall through to generic resolution if Rust-specific didn't match - } - - // ---- Generic relative import resolution (./ and ../) ---- - const currentDir = currentFile.split('/').slice(0, -1); - const parts = importPath.split('/'); - - for (const part of parts) { - if (part === '.') continue; - if (part === '..') { - currentDir.pop(); - } else { - currentDir.push(part); + // C#: handle namespace-based imports (using directives) + if (language === SupportedLanguages.CSharp && csharpConfigs.length > 0) { + const resolvedFiles = resolveCSharpImport(rawImportPath, csharpConfigs, normalizedFileList, allFileList, index); + if (resolvedFiles.length > 1) { + const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs); + if (dirSuffix) { + return { kind: 'package', files: resolvedFiles, dirSuffix }; + } } - } - - const basePath = currentDir.join('/'); - - if (importPath.startsWith('.')) { - const resolved = tryResolveWithExtensions(basePath, allFiles); - return cache(resolved); - } - - // ---- Generic package/absolute import resolution (suffix matching) ---- - // Java wildcards are handled in processImports, not here - if (importPath.endsWith('.*')) { - return cache(null); - } - - const pathLike = importPath.includes('/') - ? importPath - : importPath.replace(/\./g, '/'); - const pathParts = pathLike.split('/').filter(Boolean); - - const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index); - return cache(resolved); -}; - -// ============================================================================ -// RUST MODULE RESOLUTION -// ============================================================================ - -/** - * Resolve Rust use-path to a file. - * Handles crate::, super::, self:: prefixes and :: path separators. - */ -function resolveRustImport( - currentFile: string, - importPath: string, - allFiles: Set<string>, -): string | null { - let rustPath: string; - - if (importPath.startsWith('crate::')) { - // crate:: resolves from src/ directory (standard Rust layout) - rustPath = importPath.slice(7).replace(/::/g, '/'); - - // Try from src/ (standard layout) - const fromSrc = tryRustModulePath('src/' + rustPath, allFiles); - if (fromSrc) return fromSrc; - - // Try from repo root (non-standard) - const fromRoot = tryRustModulePath(rustPath, allFiles); - if (fromRoot) return fromRoot; - + if (resolvedFiles.length > 0) return { kind: 'files', files: resolvedFiles }; return null; } - if (importPath.startsWith('super::')) { - // super:: = parent directory of current file's module - const currentDir = currentFile.split('/').slice(0, -1); - currentDir.pop(); // Go up one level for super:: - rustPath = importPath.slice(7).replace(/::/g, '/'); - const fullPath = [...currentDir, rustPath].join('/'); - return tryRustModulePath(fullPath, allFiles); + // PHP: handle namespace-based imports (use statements) + if (language === SupportedLanguages.PHP) { + const resolved = resolvePhpImport(rawImportPath, composerConfig, allFilePaths, normalizedFileList, allFileList, index); + return resolved ? { kind: 'files', files: [resolved] } : null; } - if (importPath.startsWith('self::')) { - // self:: = current module's directory - const currentDir = currentFile.split('/').slice(0, -1); - rustPath = importPath.slice(6).replace(/::/g, '/'); - const fullPath = [...currentDir, rustPath].join('/'); - return tryRustModulePath(fullPath, allFiles); + // Swift: handle module imports + if (language === SupportedLanguages.Swift && swiftPackageConfig) { + const targetDir = swiftPackageConfig.targets.get(rawImportPath); + if (targetDir) { + const dirPrefix = targetDir + '/'; + const files: string[] = []; + for (let i = 0; i < normalizedFileList.length; i++) { + if (normalizedFileList[i].startsWith(dirPrefix) && normalizedFileList[i].endsWith('.swift')) { + files.push(allFileList[i]); + } + } + if (files.length > 0) return { kind: 'files', files }; + } + return null; // External framework (Foundation, UIKit, etc.) } - // Bare path without prefix (e.g., from a use in a nested module) - // Convert :: to / and try suffix matching - if (importPath.includes('::')) { - rustPath = importPath.replace(/::/g, '/'); - return tryRustModulePath(rustPath, allFiles); + // Python: relative imports (PEP 328) + proximity-based bare imports + // Falls through to standard suffix resolution when proximity finds no match. + if (language === SupportedLanguages.Python) { + const resolved = resolvePythonImport(filePath, rawImportPath, allFilePaths); + if (resolved) return { kind: 'files', files: [resolved] }; + if (rawImportPath.startsWith('.')) return null; // relative but unresolved — don't suffix-match } - return null; + // Ruby: require / require_relative + if (language === SupportedLanguages.Ruby) { + const resolved = resolveRubyImport(rawImportPath, normalizedFileList, allFileList, index); + return resolved ? { kind: 'files', files: [resolved] } : null; + } + + // Rust: expand top-level grouped imports: use {crate::a, crate::b} + if (language === SupportedLanguages.Rust && rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) { + const inner = rawImportPath.slice(1, -1); + const parts = inner.split(',').map(p => p.trim()).filter(Boolean); + const resolved: string[] = []; + for (const part of parts) { + const r = resolveRustImport(filePath, part, allFilePaths); + if (r) resolved.push(r); + } + return resolved.length > 0 ? { kind: 'files', files: resolved } : null; + } + + // Standard single-file resolution + const resolvedPath = resolveImportPath( + filePath, + rawImportPath, + allFilePaths, + allFileList, + normalizedFileList, + resolveCache, + language, + tsconfigPaths, + index, + ); + + return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null; } /** - * Try to resolve a Rust module path to a file. - * Tries: path.rs, path/mod.rs, and with the last segment stripped - * (last segment might be a symbol name, not a module). + * Apply an ImportResult: emit graph edges and update ImportMap/PackageMap. + * If namedBindings are provided and the import resolves to a single file, + * also populate the NamedImportMap for precise Tier 2a resolution. */ -function tryRustModulePath(modulePath: string, allFiles: Set<string>): string | null { - // Try direct: path.rs - if (allFiles.has(modulePath + '.rs')) return modulePath + '.rs'; - // Try directory: path/mod.rs - if (allFiles.has(modulePath + '/mod.rs')) return modulePath + '/mod.rs'; - // Try path/lib.rs (for crate root) - if (allFiles.has(modulePath + '/lib.rs')) return modulePath + '/lib.rs'; +function applyImportResult( + result: ImportResult, + filePath: string, + importMap: ImportMap, + packageMap: PackageMap | undefined, + addImportEdge: (from: string, to: string) => void, + addImportGraphEdge: (from: string, to: string) => void, + namedBindings?: { local: string; exported: string }[], + namedImportMap?: NamedImportMap, +): void { + if (!result) return; - // The last segment might be a symbol (function, struct, etc.), not a module. - // Strip it and try again. - const lastSlash = modulePath.lastIndexOf('/'); - if (lastSlash > 0) { - const parentPath = modulePath.substring(0, lastSlash); - if (allFiles.has(parentPath + '.rs')) return parentPath + '.rs'; - if (allFiles.has(parentPath + '/mod.rs')) return parentPath + '/mod.rs'; - } + if (result.kind === 'package' && packageMap) { + // Store directory suffix in PackageMap (skip ImportMap expansion) + for (const resolvedFile of result.files) { + addImportGraphEdge(filePath, resolvedFile); + } + if (!packageMap.has(filePath)) packageMap.set(filePath, new Set()); + packageMap.get(filePath)!.add(result.dirSuffix); + } else { + // 'files' kind, or 'package' without PackageMap — use ImportMap directly + const files = result.files; + for (const resolvedFile of files) { + addImportEdge(filePath, resolvedFile); + } - return null; -} - -// ============================================================================ -// JAVA MULTI-FILE RESOLUTION -// ============================================================================ - -/** - * Resolve a Java wildcard import (com.example.*) to all matching .java files. - * Returns an array of file paths. - */ -function resolveJavaWildcard( - importPath: string, - normalizedFileList: string[], - allFileList: string[], - index?: SuffixIndex, -): string[] { - // "com.example.util.*" -> "com/example/util" - const packagePath = importPath.slice(0, -2).replace(/\./g, '/'); - - if (index) { - // Use directory index: get all .java files in this package directory - const candidates = index.getFilesInDir(packagePath, '.java'); - // Filter to only direct children (no subdirectories) - const packageSuffix = '/' + packagePath + '/'; - return candidates.filter(f => { - const normalized = f.replace(/\\/g, '/'); - const idx = normalized.indexOf(packageSuffix); - if (idx < 0) return false; - const afterPkg = normalized.substring(idx + packageSuffix.length); - return !afterPkg.includes('/'); - }); - } - - // Fallback: linear scan - const packageSuffix = '/' + packagePath + '/'; - const matches: string[] = []; - for (let i = 0; i < normalizedFileList.length; i++) { - const normalized = normalizedFileList[i]; - if (normalized.includes(packageSuffix) && normalized.endsWith('.java')) { - const afterPackage = normalized.substring(normalized.indexOf(packageSuffix) + packageSuffix.length); - if (!afterPackage.includes('/')) { - matches.push(allFileList[i]); + // Record named bindings for precise Tier 2a resolution + if (namedBindings && namedImportMap && files.length === 1) { + const resolvedFile = files[0]; + if (!namedImportMap.has(filePath)) namedImportMap.set(filePath, new Map()); + const fileBindings = namedImportMap.get(filePath)!; + for (const binding of namedBindings) { + fileBindings.set(binding.local, { sourcePath: resolvedFile, exportedName: binding.exported }); } } } - return matches; -} - -/** - * Try to resolve a Java static import by stripping the member name. - * "com.example.Constants.VALUE" -> resolve "com.example.Constants" - */ -function resolveJavaStaticImport( - importPath: string, - normalizedFileList: string[], - allFileList: string[], - index?: SuffixIndex, -): string | null { - // Static imports look like: com.example.Constants.VALUE or com.example.Constants.* - // The last segment is a member name (field/method) if it starts with lowercase or is ALL_CAPS - const segments = importPath.split('.'); - if (segments.length < 3) return null; - - const lastSeg = segments[segments.length - 1]; - // If last segment is a wildcard or ALL_CAPS constant or starts with lowercase, strip it - if (lastSeg === '*' || /^[a-z]/.test(lastSeg) || /^[A-Z_]+$/.test(lastSeg)) { - const classPath = segments.slice(0, -1).join('/'); - const classSuffix = classPath + '.java'; - - if (index) { - return index.get(classSuffix) || index.getInsensitive(classSuffix) || null; - } - - // Fallback: linear scan - const fullSuffix = '/' + classSuffix; - for (let i = 0; i < normalizedFileList.length; i++) { - if (normalizedFileList[i].endsWith(fullSuffix) || - normalizedFileList[i].toLowerCase().endsWith(fullSuffix.toLowerCase())) { - return allFileList[i]; - } - } - } - - return null; -} - -// ============================================================================ -// GO PACKAGE RESOLUTION -// ============================================================================ - -/** - * Resolve a Go internal package import to all .go files in the package directory. - * Returns an array of file paths. - */ -function resolveGoPackage( - importPath: string, - goModule: GoModuleConfig, - normalizedFileList: string[], - allFileList: string[], -): string[] { - if (!importPath.startsWith(goModule.modulePath)) return []; - - // Strip module path to get relative package path - const relativePkg = importPath.slice(goModule.modulePath.length + 1); // e.g., "internal/auth" - if (!relativePkg) return []; - - const pkgSuffix = '/' + relativePkg + '/'; - const matches: string[] = []; - - for (let i = 0; i < normalizedFileList.length; i++) { - const normalized = normalizedFileList[i]; - // File must be directly in the package directory (not a subdirectory) - if (normalized.includes(pkgSuffix) && normalized.endsWith('.go') && !normalized.endsWith('_test.go')) { - const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length); - if (!afterPkg.includes('/')) { - matches.push(allFileList[i]); - } - } - } - - return matches; } // ============================================================================ @@ -559,15 +313,21 @@ export const processImports = async ( graph: KnowledgeGraph, files: { path: string; content: string }[], astCache: ASTCache, - importMap: ImportMap, + ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, + allPaths?: string[], ) => { - // Create a Set of all file paths for fast lookup during resolution - const allFilePaths = new Set(files.map(f => f.path)); + const importMap = ctx.importMap; + const packageMap = ctx.packageMap; + const namedImportMap = ctx.namedImportMap; + // Use allPaths (full repo) when available for cross-chunk resolution, else fall back to chunk files + const allFileList = allPaths ?? files.map(f => f.path); + const allFilePaths = new Set(allFileList); const parser = await loadParser(); + const logSkipped = isVerboseIngestionEnabled(); + const skippedByLang = logSkipped ? new Map<string, number>() : null; const resolveCache = new Map<string, string | null>(); - const allFileList = files.map(f => f.path); // Pre-compute normalized file list once (forward slashes) const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/')); // Build suffix index for O(1) lookups @@ -579,11 +339,17 @@ export const processImports = async ( // Load language-specific configs once before the file loop const effectiveRoot = repoRoot || ''; - const tsconfigPaths = await loadTsconfigPaths(effectiveRoot); - const goModule = await loadGoModulePath(effectiveRoot); + const configs: LanguageConfigs = { + tsconfigPaths: await loadTsconfigPaths(effectiveRoot), + goModule: await loadGoModulePath(effectiveRoot), + composerConfig: await loadComposerConfig(effectiveRoot), + swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot), + csharpConfigs: await loadCSharpProjectConfig(effectiveRoot), + }; + const resolveCtx: ResolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache }; - // Helper: add an IMPORTS edge + update import map - const addImportEdge = (filePath: string, resolvedPath: string) => { + // Helper: add an IMPORTS edge to the graph only (no ImportMap update) + const addImportGraphEdge = (filePath: string, resolvedPath: string) => { const sourceId = generateId('File', filePath); const targetId = generateId('File', resolvedPath); const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`); @@ -598,6 +364,11 @@ export const processImports = async ( confidence: 1.0, reason: '', }); + }; + + // Helper: add an IMPORTS edge + update import map + const addImportEdge = (filePath: string, resolvedPath: string) => { + addImportGraphEdge(filePath, resolvedPath); if (!importMap.has(filePath)) { importMap.set(filePath, new Set()); @@ -613,6 +384,12 @@ export const processImports = async ( // 1. Check language support first const language = getLanguageFromFilename(file.path); if (!language) continue; + if (!isLanguageAvailable(language)) { + if (skippedByLang) { + skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1); + } + continue; + } const queryStr = LANGUAGE_QUERIES[language]; if (!queryStr) continue; @@ -626,7 +403,7 @@ export const processImports = async ( if (!tree) { try { - tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 }); + tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) }); } catch (parseError) { continue; } @@ -671,55 +448,27 @@ export const processImports = async ( } // Clean path (remove quotes and angle brackets for C/C++ includes) - const rawImportPath = sourceNode.text.replace(/['"<>]/g, ''); + const rawImportPath = language === SupportedLanguages.Kotlin + ? appendKotlinWildcard(sourceNode.text.replace(/['"<>]/g, ''), captureMap['import']) + : sourceNode.text.replace(/['"<>]/g, ''); totalImportsFound++; - // ---- Java: handle wildcards and static imports specially ---- - if (language === SupportedLanguages.Java) { - if (rawImportPath.endsWith('.*')) { - const matchedFiles = resolveJavaWildcard(rawImportPath, normalizedFileList, allFileList, index); - for (const matchedFile of matchedFiles) { - addImportEdge(file.path, matchedFile); - } - return; // skip single-file resolution + const result = resolveLanguageImport(file.path, rawImportPath, language, configs, resolveCtx); + const bindings = namedImportMap ? extractNamedBindings(captureMap['import'], language) : undefined; + applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap); + } + + // ---- Language-specific call-as-import routing (Ruby require, etc.) ---- + if (captureMap['call']) { + const callNameNode = captureMap['call.name']; + if (callNameNode) { + const callRouter = callRouters[language]; + const routed = callRouter(callNameNode.text, captureMap['call']); + if (routed && routed.kind === 'import') { + totalImportsFound++; + const result = resolveLanguageImport(file.path, routed.importPath, language, configs, resolveCtx); + applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge); } - - // Try static import resolution (strip member name) - const staticResolved = resolveJavaStaticImport(rawImportPath, normalizedFileList, allFileList, index); - if (staticResolved) { - addImportEdge(file.path, staticResolved); - return; - } - // Fall through to normal resolution for regular Java imports - } - - // ---- Go: handle package-level imports ---- - if (language === SupportedLanguages.Go && goModule && rawImportPath.startsWith(goModule.modulePath)) { - const pkgFiles = resolveGoPackage(rawImportPath, goModule, normalizedFileList, allFileList); - if (pkgFiles.length > 0) { - for (const pkgFile of pkgFiles) { - addImportEdge(file.path, pkgFile); - } - return; // skip single-file resolution - } - // Fall through if no files found (package might be external) - } - - // ---- Standard single-file resolution ---- - const resolvedPath = resolveImportPath( - file.path, - rawImportPath, - allFilePaths, - allFileList, - normalizedFileList, - resolveCache, - language, - tsconfigPaths, - index, - ); - - if (resolvedPath) { - addImportEdge(file.path, resolvedPath); } } }); @@ -727,6 +476,14 @@ export const processImports = async ( // Tree is now owned by the LRU cache — no manual delete needed } + if (skippedByLang && skippedByLang.size > 0) { + for (const [lang, count] of skippedByLang.entries()) { + console.warn( + `[ingestion] Skipped ${count} ${lang} file(s) in import processing — ${lang} parser not available.` + ); + } + } + if (isDev) { console.log(`📊 Import processing complete: ${totalImportsResolved}/${totalImportsFound} imports resolved to graph edges`); } @@ -738,27 +495,34 @@ export const processImports = async ( export const processImportsFromExtracted = async ( graph: KnowledgeGraph, - files: { path: string; content: string }[], + files: { path: string }[], extractedImports: ExtractedImport[], - importMap: ImportMap, + ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, + prebuiltCtx?: ImportResolutionContext, ) => { - const allFilePaths = new Set(files.map(f => f.path)); - const resolveCache = new Map<string, string | null>(); - const allFileList = files.map(f => f.path); - const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/')); - // Build suffix index for O(1) lookups - const index = buildSuffixIndex(normalizedFileList, allFileList); + const importMap = ctx.importMap; + const packageMap = ctx.packageMap; + const namedImportMap = ctx.namedImportMap; + const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map(f => f.path)); + const { allFilePaths, allFileList, normalizedFileList, suffixIndex: index, resolveCache } = importCtx; let totalImportsFound = 0; let totalImportsResolved = 0; const effectiveRoot = repoRoot || ''; - const tsconfigPaths = await loadTsconfigPaths(effectiveRoot); - const goModule = await loadGoModulePath(effectiveRoot); + const configs: LanguageConfigs = { + tsconfigPaths: await loadTsconfigPaths(effectiveRoot), + goModule: await loadGoModulePath(effectiveRoot), + composerConfig: await loadComposerConfig(effectiveRoot), + swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot), + csharpConfigs: await loadCSharpProjectConfig(effectiveRoot), + }; + const resolveCtx: ResolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache }; - const addImportEdge = (filePath: string, resolvedPath: string) => { + // Helper: add an IMPORTS edge to the graph only (no ImportMap update) + const addImportGraphEdge = (filePath: string, resolvedPath: string) => { const sourceId = generateId('File', filePath); const targetId = generateId('File', resolvedPath); const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`); @@ -773,6 +537,10 @@ export const processImportsFromExtracted = async ( confidence: 1.0, reason: '', }); + }; + + const addImportEdge = (filePath: string, resolvedPath: string) => { + addImportGraphEdge(filePath, resolvedPath); if (!importMap.has(filePath)) { importMap.set(filePath, new Set()); @@ -794,21 +562,6 @@ export const processImportsFromExtracted = async ( const totalFiles = importsByFile.size; let filesProcessed = 0; - // Pre-build a suffix index for O(1) suffix lookups instead of O(n) linear scans - const suffixIndex = new Map<string, string[]>(); - for (let i = 0; i < normalizedFileList.length; i++) { - const normalized = normalizedFileList[i]; - // Index by last path segment (filename) for fast suffix matching - const lastSlash = normalized.lastIndexOf('/'); - const filename = lastSlash >= 0 ? normalized.substring(lastSlash + 1) : normalized; - let list = suffixIndex.get(filename); - if (!list) { - list = []; - suffixIndex.set(filename, list); - } - list.push(allFileList[i]); - } - for (const [filePath, fileImports] of importsByFile) { filesProcessed++; if (filesProcessed % 100 === 0) { @@ -816,62 +569,11 @@ export const processImportsFromExtracted = async ( await yieldToEventLoop(); } - for (const { rawImportPath, language } of fileImports) { + for (const imp of fileImports) { totalImportsFound++; - // Check resolve cache first - const cacheKey = `${filePath}::${rawImportPath}`; - if (resolveCache.has(cacheKey)) { - const cached = resolveCache.get(cacheKey); - if (cached) addImportEdge(filePath, cached); - continue; - } - - // Java: handle wildcards and static imports - if (language === SupportedLanguages.Java) { - if (rawImportPath.endsWith('.*')) { - const matchedFiles = resolveJavaWildcard(rawImportPath, normalizedFileList, allFileList, index); - for (const matchedFile of matchedFiles) { - addImportEdge(filePath, matchedFile); - } - continue; - } - - const staticResolved = resolveJavaStaticImport(rawImportPath, normalizedFileList, allFileList, index); - if (staticResolved) { - resolveCache.set(cacheKey, staticResolved); - addImportEdge(filePath, staticResolved); - continue; - } - } - - // Go: handle package-level imports - if (language === SupportedLanguages.Go && goModule && rawImportPath.startsWith(goModule.modulePath)) { - const pkgFiles = resolveGoPackage(rawImportPath, goModule, normalizedFileList, allFileList); - if (pkgFiles.length > 0) { - for (const pkgFile of pkgFiles) { - addImportEdge(filePath, pkgFile); - } - continue; - } - } - - // Standard resolution (has its own internal cache) - const resolvedPath = resolveImportPath( - filePath, - rawImportPath, - allFilePaths, - allFileList, - normalizedFileList, - resolveCache, - language as SupportedLanguages, - tsconfigPaths, - index, - ); - - if (resolvedPath) { - addImportEdge(filePath, resolvedPath); - } + const result = resolveLanguageImport(filePath, imp.rawImportPath, imp.language, configs, resolveCtx); + applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap); } } diff --git a/gitnexus/src/core/ingestion/language-config.ts b/gitnexus/src/core/ingestion/language-config.ts new file mode 100644 index 0000000000..cd64ca10dc --- /dev/null +++ b/gitnexus/src/core/ingestion/language-config.ts @@ -0,0 +1,215 @@ +import fs from 'fs/promises'; +import path from 'path'; + +const isDev = process.env.NODE_ENV === 'development'; + +// ============================================================================ +// LANGUAGE-SPECIFIC CONFIG TYPES +// ============================================================================ + +/** TypeScript path alias config parsed from tsconfig.json */ +export interface TsconfigPaths { + /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */ + aliases: Map<string, string>; + /** Base URL for path resolution (relative to repo root) */ + baseUrl: string; +} + +/** Go module config parsed from go.mod */ +export interface GoModuleConfig { + /** Module path (e.g., "github.com/user/repo") */ + modulePath: string; +} + +/** PHP Composer PSR-4 autoload config */ +export interface ComposerConfig { + /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */ + psr4: Map<string, string>; +} + +/** C# project config parsed from .csproj files */ +export interface CSharpProjectConfig { + /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */ + rootNamespace: string; + /** Directory containing the .csproj file */ + projectDir: string; +} + +/** Swift Package Manager module config */ +export interface SwiftPackageConfig { + /** Map of target name -> source directory path (e.g., "SiuperModel" -> "Package/Sources/SiuperModel") */ + targets: Map<string, string>; +} + +// ============================================================================ +// LANGUAGE-SPECIFIC CONFIG LOADERS +// ============================================================================ + +/** + * Parse tsconfig.json to extract path aliases. + * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order. + */ +export async function loadTsconfigPaths(repoRoot: string): Promise<TsconfigPaths | null> { + const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json']; + + for (const filename of candidates) { + try { + const tsconfigPath = path.join(repoRoot, filename); + const raw = await fs.readFile(tsconfigPath, 'utf-8'); + // Strip JSON comments (// and /* */ style) for robustness + const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, ''); + const tsconfig = JSON.parse(stripped); + const compilerOptions = tsconfig.compilerOptions; + if (!compilerOptions?.paths) continue; + + const baseUrl = compilerOptions.baseUrl || '.'; + const aliases = new Map<string, string>(); + + for (const [pattern, targets] of Object.entries(compilerOptions.paths)) { + if (!Array.isArray(targets) || targets.length === 0) continue; + const target = targets[0] as string; + + // Convert glob patterns: "@/*" -> "@/", "src/*" -> "src/" + const aliasPrefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern; + const targetPrefix = target.endsWith('/*') ? target.slice(0, -1) : target; + + aliases.set(aliasPrefix, targetPrefix); + } + + if (aliases.size > 0) { + if (isDev) { + console.log(`📦 Loaded ${aliases.size} path aliases from ${filename}`); + } + return { aliases, baseUrl }; + } + } catch { + // File doesn't exist or isn't valid JSON - try next + } + } + + return null; +} + +/** + * Parse go.mod to extract module path. + */ +export async function loadGoModulePath(repoRoot: string): Promise<GoModuleConfig | null> { + try { + const goModPath = path.join(repoRoot, 'go.mod'); + const content = await fs.readFile(goModPath, 'utf-8'); + const match = content.match(/^module\s+(\S+)/m); + if (match) { + if (isDev) { + console.log(`📦 Loaded Go module path: ${match[1]}`); + } + return { modulePath: match[1] }; + } + } catch { + // No go.mod + } + return null; +} + +/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */ +export async function loadComposerConfig(repoRoot: string): Promise<ComposerConfig | null> { + try { + const composerPath = path.join(repoRoot, 'composer.json'); + const raw = await fs.readFile(composerPath, 'utf-8'); + const composer = JSON.parse(raw); + const psr4Raw = composer.autoload?.['psr-4'] ?? {}; + const psr4Dev = composer['autoload-dev']?.['psr-4'] ?? {}; + const merged = { ...psr4Raw, ...psr4Dev }; + + const psr4 = new Map<string, string>(); + for (const [ns, dir] of Object.entries(merged)) { + const nsNorm = (ns as string).replace(/\\+$/, ''); + const dirNorm = (dir as string).replace(/\\/g, '/').replace(/\/+$/, ''); + psr4.set(nsNorm, dirNorm); + } + + if (isDev) { + console.log(`📦 Loaded ${psr4.size} PSR-4 mappings from composer.json`); + } + return { psr4 }; + } catch { + return null; + } +} + +/** + * Parse .csproj files to extract RootNamespace. + * Scans the repo root for .csproj files and returns configs for each. + */ +export async function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]> { + const configs: CSharpProjectConfig[] = []; + // BFS scan for .csproj files up to 5 levels deep, cap at 100 dirs to avoid runaway scanning + const scanQueue: { dir: string; depth: number }[] = [{ dir: repoRoot, depth: 0 }]; + const maxDepth = 5; + const maxDirs = 100; + let dirsScanned = 0; + + while (scanQueue.length > 0 && dirsScanned < maxDirs) { + const { dir, depth } = scanQueue.shift()!; + dirsScanned++; + try { + const entries = await fs.readdir(dir, { withFileTypes: true }); + for (const entry of entries) { + if (entry.isDirectory() && depth < maxDepth) { + // Skip common non-project directories + if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'bin' || entry.name === 'obj') continue; + scanQueue.push({ dir: path.join(dir, entry.name), depth: depth + 1 }); + } + if (entry.isFile() && entry.name.endsWith('.csproj')) { + try { + const csprojPath = path.join(dir, entry.name); + const content = await fs.readFile(csprojPath, 'utf-8'); + const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/); + const rootNamespace = nsMatch + ? nsMatch[1].trim() + : entry.name.replace(/\.csproj$/, ''); + const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/'); + configs.push({ rootNamespace, projectDir }); + if (isDev) { + console.log(`📦 Loaded C# project: ${entry.name} (namespace: ${rootNamespace}, dir: ${projectDir})`); + } + } catch { + // Can't read .csproj + } + } + } + } catch { + // Can't read directory + } + } + return configs; +} + +export async function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null> { + // Swift imports are module-name based (e.g., `import SiuperModel`) + // SPM convention: Sources/<TargetName>/ or Package/Sources/<TargetName>/ + // We scan for these directories to build a target map + const targets = new Map<string, string>(); + + const sourceDirs = ['Sources', 'Package/Sources', 'src']; + for (const sourceDir of sourceDirs) { + try { + const fullPath = path.join(repoRoot, sourceDir); + const entries = await fs.readdir(fullPath, { withFileTypes: true }); + for (const entry of entries) { + if (entry.isDirectory()) { + targets.set(entry.name, sourceDir + '/' + entry.name); + } + } + } catch { + // Directory doesn't exist + } + } + + if (targets.size > 0) { + if (isDev) { + console.log(`📦 Loaded ${targets.size} Swift package targets`); + } + return { targets }; + } + return null; +} diff --git a/gitnexus/src/core/ingestion/mro-processor.ts b/gitnexus/src/core/ingestion/mro-processor.ts new file mode 100644 index 0000000000..a683e9a616 --- /dev/null +++ b/gitnexus/src/core/ingestion/mro-processor.ts @@ -0,0 +1,465 @@ +/** + * MRO (Method Resolution Order) Processor + * + * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from + * each ancestor via HAS_METHOD edges, detects method-name collisions across + * parents, and applies language-specific resolution rules to emit OVERRIDES edges. + * + * Language-specific rules: + * - C++: leftmost base class in declaration order wins + * - C#/Java: class method wins over interface default; multiple interface + * methods with same name are ambiguous (null resolution) + * - Python: C3 linearization determines MRO; first in linearized order wins + * - Rust: no auto-resolution — requires qualified syntax, resolvedTo = null + * - Default: single inheritance — first definition wins + * + * OVERRIDES edge direction: Class → Method (not Method → Method). + * The source is the child class that inherits conflicting methods, + * the target is the winning ancestor method node. + * Cypher: MATCH (c:Class)-[r:CodeRelation {type: 'OVERRIDES'}]->(m:Method) + */ + +import { KnowledgeGraph, GraphRelationship } from '../graph/types.js'; +import { generateId } from '../../lib/utils.js'; +import { SupportedLanguages } from '../../config/supported-languages.js'; + +// --------------------------------------------------------------------------- +// Public types +// --------------------------------------------------------------------------- + +export interface MROEntry { + classId: string; + className: string; + language: SupportedLanguages; + mro: string[]; // linearized parent names + ambiguities: MethodAmbiguity[]; +} + +export interface MethodAmbiguity { + methodName: string; + definedIn: Array<{ classId: string; className: string; methodId: string }>; + resolvedTo: string | null; // winning methodId or null if truly ambiguous + reason: string; +} + +export interface MROResult { + entries: MROEntry[]; + overrideEdges: number; + ambiguityCount: number; +} + +// --------------------------------------------------------------------------- +// Internal helpers +// --------------------------------------------------------------------------- + +/** Collect EXTENDS, IMPLEMENTS, and HAS_METHOD adjacency from the graph. */ +function buildAdjacency(graph: KnowledgeGraph) { + // parentMap: childId → parentIds[] (in insertion / declaration order) + const parentMap = new Map<string, string[]>(); + // methodMap: classId → methodIds[] + const methodMap = new Map<string, string[]>(); + // Track which edge type each parent link came from + const parentEdgeType = new Map<string, Map<string, 'EXTENDS' | 'IMPLEMENTS'>>(); + + graph.forEachRelationship((rel) => { + if (rel.type === 'EXTENDS' || rel.type === 'IMPLEMENTS') { + let parents = parentMap.get(rel.sourceId); + if (!parents) { + parents = []; + parentMap.set(rel.sourceId, parents); + } + parents.push(rel.targetId); + + let edgeTypes = parentEdgeType.get(rel.sourceId); + if (!edgeTypes) { + edgeTypes = new Map(); + parentEdgeType.set(rel.sourceId, edgeTypes); + } + edgeTypes.set(rel.targetId, rel.type); + } + + if (rel.type === 'HAS_METHOD') { + let methods = methodMap.get(rel.sourceId); + if (!methods) { + methods = []; + methodMap.set(rel.sourceId, methods); + } + methods.push(rel.targetId); + } + }); + + return { parentMap, methodMap, parentEdgeType }; +} + +/** + * Gather all ancestor IDs in BFS / topological order. + * Returns the linearized list of ancestor IDs (excluding the class itself). + */ +function gatherAncestors( + classId: string, + parentMap: Map<string, string[]>, +): string[] { + const visited = new Set<string>(); + const order: string[] = []; + const queue: string[] = [...(parentMap.get(classId) ?? [])]; + + while (queue.length > 0) { + const id = queue.shift()!; + if (visited.has(id)) continue; + visited.add(id); + order.push(id); + const grandparents = parentMap.get(id); + if (grandparents) { + for (const gp of grandparents) { + if (!visited.has(gp)) queue.push(gp); + } + } + } + + return order; +} + +// --------------------------------------------------------------------------- +// C3 linearization (Python MRO) +// --------------------------------------------------------------------------- + +/** + * Compute C3 linearization for a class given a parentMap. + * Returns an array of ancestor IDs in C3 order (excluding the class itself), + * or null if linearization fails (inconsistent or cyclic hierarchy). + */ +function c3Linearize( + classId: string, + parentMap: Map<string, string[]>, + cache: Map<string, string[] | null>, + inProgress?: Set<string>, +): string[] | null { + if (cache.has(classId)) return cache.get(classId)!; + + // Cycle detection: if we're already computing this class, the hierarchy is cyclic + const visiting = inProgress ?? new Set<string>(); + if (visiting.has(classId)) { + cache.set(classId, null); + return null; + } + visiting.add(classId); + + const directParents = parentMap.get(classId); + if (!directParents || directParents.length === 0) { + visiting.delete(classId); + cache.set(classId, []); + return []; + } + + // Compute linearization for each parent first + const parentLinearizations: string[][] = []; + for (const pid of directParents) { + const pLin = c3Linearize(pid, parentMap, cache, visiting); + if (pLin === null) { + visiting.delete(classId); + cache.set(classId, null); + return null; + } + parentLinearizations.push([pid, ...pLin]); + } + + // Add the direct parents list as the final sequence + const sequences = [...parentLinearizations, [...directParents]]; + const result: string[] = []; + + while (sequences.some(s => s.length > 0)) { + // Find a good head: one that doesn't appear in the tail of any other sequence + let head: string | null = null; + for (const seq of sequences) { + if (seq.length === 0) continue; + const candidate = seq[0]; + const inTail = sequences.some( + other => other.length > 1 && other.indexOf(candidate, 1) !== -1 + ); + if (!inTail) { + head = candidate; + break; + } + } + + if (head === null) { + // Inconsistent hierarchy + visiting.delete(classId); + cache.set(classId, null); + return null; + } + + result.push(head); + + // Remove the chosen head from all sequences + for (const seq of sequences) { + if (seq.length > 0 && seq[0] === head) { + seq.shift(); + } + } + } + + visiting.delete(classId); + cache.set(classId, result); + return result; +} + +// --------------------------------------------------------------------------- +// Language-specific resolution +// --------------------------------------------------------------------------- + +type MethodDef = { classId: string; className: string; methodId: string }; +type Resolution = { resolvedTo: string | null; reason: string }; + +/** Resolve by MRO order — first ancestor in linearized order wins. */ +function resolveByMroOrder( + methodName: string, + defs: MethodDef[], + mroOrder: string[], + reasonPrefix: string, +): Resolution { + for (const ancestorId of mroOrder) { + const match = defs.find(d => d.classId === ancestorId); + if (match) { + return { + resolvedTo: match.methodId, + reason: `${reasonPrefix}: ${match.className}::${methodName}`, + }; + } + } + return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition` }; +} + +function resolveCsharpJava( + methodName: string, + defs: MethodDef[], + parentEdgeTypes: Map<string, 'EXTENDS' | 'IMPLEMENTS'> | undefined, +): Resolution { + const classDefs: MethodDef[] = []; + const interfaceDefs: MethodDef[] = []; + + for (const def of defs) { + const edgeType = parentEdgeTypes?.get(def.classId); + if (edgeType === 'IMPLEMENTS') { + interfaceDefs.push(def); + } else { + classDefs.push(def); + } + } + + if (classDefs.length > 0) { + return { + resolvedTo: classDefs[0].methodId, + reason: `class method wins: ${classDefs[0].className}::${methodName}`, + }; + } + + if (interfaceDefs.length > 1) { + return { + resolvedTo: null, + reason: `ambiguous: ${methodName} defined in multiple interfaces: ${interfaceDefs.map(d => d.className).join(', ')}`, + }; + } + + if (interfaceDefs.length === 1) { + return { + resolvedTo: interfaceDefs[0].methodId, + reason: `single interface default: ${interfaceDefs[0].className}::${methodName}`, + }; + } + + return { resolvedTo: null, reason: 'no resolution found' }; +} + +// --------------------------------------------------------------------------- +// Main entry point +// --------------------------------------------------------------------------- + +export function computeMRO(graph: KnowledgeGraph): MROResult { + const { parentMap, methodMap, parentEdgeType } = buildAdjacency(graph); + const c3Cache = new Map<string, string[] | null>(); + + const entries: MROEntry[] = []; + let overrideEdges = 0; + let ambiguityCount = 0; + + // Process every class that has at least one parent + for (const [classId, directParents] of parentMap) { + if (directParents.length === 0) continue; + + const classNode = graph.getNode(classId); + if (!classNode) continue; + + const language = classNode.properties.language; + if (!language) continue; + const className = classNode.properties.name; + + // Compute linearized MRO depending on language + let mroOrder: string[]; + if (language === SupportedLanguages.Python) { + const c3Result = c3Linearize(classId, parentMap, c3Cache); + mroOrder = c3Result ?? gatherAncestors(classId, parentMap); + } else { + mroOrder = gatherAncestors(classId, parentMap); + } + + // Get the parent names for the MRO entry + const mroNames: string[] = mroOrder + .map(id => graph.getNode(id)?.properties.name) + .filter((n): n is string => n !== undefined); + + // Collect methods from all ancestors, grouped by method name + const methodsByName = new Map<string, MethodDef[]>(); + for (const ancestorId of mroOrder) { + const ancestorNode = graph.getNode(ancestorId); + if (!ancestorNode) continue; + + const methods = methodMap.get(ancestorId) ?? []; + for (const methodId of methods) { + const methodNode = graph.getNode(methodId); + if (!methodNode) continue; + // Properties don't participate in method resolution order + if (methodNode.label === 'Property') continue; + + const methodName = methodNode.properties.name; + let defs = methodsByName.get(methodName); + if (!defs) { + defs = []; + methodsByName.set(methodName, defs); + } + // Avoid duplicates (same method seen via multiple paths) + if (!defs.some(d => d.methodId === methodId)) { + defs.push({ + classId: ancestorId, + className: ancestorNode.properties.name, + methodId, + }); + } + } + } + + // Detect collisions: methods defined in 2+ different ancestors + const ambiguities: MethodAmbiguity[] = []; + + // Compute transitive edge types once per class (only needed for C#/Java) + const needsEdgeTypes = language === SupportedLanguages.CSharp || language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin; + const classEdgeTypes = needsEdgeTypes + ? buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType) + : undefined; + + for (const [methodName, defs] of methodsByName) { + if (defs.length < 2) continue; + + // Own method shadows inherited — no ambiguity + const ownMethods = methodMap.get(classId) ?? []; + const ownDefinesIt = ownMethods.some(mid => { + const mn = graph.getNode(mid); + return mn?.properties.name === methodName; + }); + if (ownDefinesIt) continue; + + let resolution: Resolution; + + switch (language) { + case SupportedLanguages.CPlusPlus: + resolution = resolveByMroOrder(methodName, defs, mroOrder, 'C++ leftmost base'); + break; + case SupportedLanguages.CSharp: + case SupportedLanguages.Java: + case SupportedLanguages.Kotlin: + resolution = resolveCsharpJava(methodName, defs, classEdgeTypes); + break; + case SupportedLanguages.Python: + resolution = resolveByMroOrder(methodName, defs, mroOrder, 'Python C3 MRO'); + break; + case SupportedLanguages.Rust: + resolution = { + resolvedTo: null, + reason: `Rust requires qualified syntax: <Type as Trait>::${methodName}()`, + }; + break; + default: + resolution = resolveByMroOrder(methodName, defs, mroOrder, 'first definition'); + break; + } + + const ambiguity: MethodAmbiguity = { + methodName, + definedIn: defs, + resolvedTo: resolution.resolvedTo, + reason: resolution.reason, + }; + ambiguities.push(ambiguity); + + if (resolution.resolvedTo === null) { + ambiguityCount++; + } + + // Emit OVERRIDES edge if resolution found + if (resolution.resolvedTo !== null) { + graph.addRelationship({ + id: generateId('OVERRIDES', `${classId}->${resolution.resolvedTo}`), + sourceId: classId, + targetId: resolution.resolvedTo, + type: 'OVERRIDES', + confidence: 1.0, + reason: resolution.reason, + }); + overrideEdges++; + } + } + + entries.push({ + classId, + className, + language, + mro: mroNames, + ambiguities, + }); + } + + return { entries, overrideEdges, ambiguityCount }; +} + +/** + * Build transitive edge types for a class using BFS from the class to all ancestors. + * + * Known limitation: BFS first-reach heuristic can misclassify an interface as + * EXTENDS if it's reachable via a class chain before being seen via IMPLEMENTS. + * E.g. if BaseClass also implements IFoo, IFoo may be classified as EXTENDS. + * This affects C#/Java/Kotlin conflict resolution in rare diamond hierarchies. + */ +function buildTransitiveEdgeTypes( + classId: string, + parentMap: Map<string, string[]>, + parentEdgeType: Map<string, Map<string, 'EXTENDS' | 'IMPLEMENTS'>>, +): Map<string, 'EXTENDS' | 'IMPLEMENTS'> { + const result = new Map<string, 'EXTENDS' | 'IMPLEMENTS'>(); + const directEdges = parentEdgeType.get(classId); + if (!directEdges) return result; + + // BFS: propagate edge type from direct parents + const queue: Array<{ id: string; edgeType: 'EXTENDS' | 'IMPLEMENTS' }> = []; + const directParents = parentMap.get(classId) ?? []; + + for (const pid of directParents) { + const et = directEdges.get(pid) ?? 'EXTENDS'; + if (!result.has(pid)) { + result.set(pid, et); + queue.push({ id: pid, edgeType: et }); + } + } + + while (queue.length > 0) { + const { id, edgeType } = queue.shift()!; + const grandparents = parentMap.get(id) ?? []; + for (const gp of grandparents) { + if (!result.has(gp)) { + result.set(gp, edgeType); + queue.push({ id: gp, edgeType }); + } + } + } + + return result; +} diff --git a/gitnexus/src/core/ingestion/named-binding-extraction.ts b/gitnexus/src/core/ingestion/named-binding-extraction.ts new file mode 100644 index 0000000000..a4a56fb272 --- /dev/null +++ b/gitnexus/src/core/ingestion/named-binding-extraction.ts @@ -0,0 +1,384 @@ +import { SupportedLanguages } from '../../config/supported-languages.js'; +import type { SymbolTable, SymbolDefinition } from './symbol-table.js'; +import type { NamedImportMap } from './import-processor.js'; + +/** + * Walk a named-binding re-export chain through NamedImportMap. + * + * When file A imports { User } from B, and B re-exports { User } from C, + * the NamedImportMap for A points to B, but B has no User definition. + * This function follows the chain: A→B→C until a definition is found. + * + * Returns the definitions found at the end of the chain, or null if the + * chain breaks (missing binding, circular reference, or depth exceeded). + * Max depth 5 to prevent infinite loops. + * + * @param allDefs Pre-computed `symbolTable.lookupFuzzy(name)` result — must be the + * complete unfiltered result. Passing a file-filtered subset will cause + * silent misses at depth=0 for non-aliased bindings. + */ +export function walkBindingChain( + name: string, + currentFilePath: string, + symbolTable: SymbolTable, + namedImportMap: NamedImportMap, + allDefs: SymbolDefinition[], +): SymbolDefinition[] | null { + let lookupFile = currentFilePath; + let lookupName = name; + const visited = new Set<string>(); + + for (let depth = 0; depth < 5; depth++) { + const bindings = namedImportMap.get(lookupFile); + if (!bindings) return null; + + const binding = bindings.get(lookupName); + if (!binding) return null; + + const key = `${binding.sourcePath}:${binding.exportedName}`; + if (visited.has(key)) return null; // circular + visited.add(key); + + const targetName = binding.exportedName; + const resolvedDefs = targetName !== lookupName || depth > 0 + ? symbolTable.lookupFuzzy(targetName).filter(def => def.filePath === binding.sourcePath) + : allDefs.filter(def => def.filePath === binding.sourcePath); + + if (resolvedDefs.length > 0) return resolvedDefs; + + // No definition in source file → follow re-export chain + lookupFile = binding.sourcePath; + lookupName = targetName; + } + + return null; +} + +/** + * Extract named bindings from an import AST node. + * Returns undefined if the import is not a named import (e.g., import * or default). + * + * TS: import { User, Repo as R } from './models' + * → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}] + * + * Python: from models import User, Repo as R + * → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}] + */ +export function extractNamedBindings( + importNode: any, + language: SupportedLanguages, +): { local: string; exported: string }[] | undefined { + if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) { + return extractTsNamedBindings(importNode); + } + if (language === SupportedLanguages.Python) { + return extractPythonNamedBindings(importNode); + } + if (language === SupportedLanguages.Kotlin) { + return extractKotlinNamedBindings(importNode); + } + if (language === SupportedLanguages.Rust) { + return extractRustNamedBindings(importNode); + } + if (language === SupportedLanguages.PHP) { + return extractPhpNamedBindings(importNode); + } + if (language === SupportedLanguages.CSharp) { + return extractCsharpNamedBindings(importNode); + } + if (language === SupportedLanguages.Java) { + return extractJavaNamedBindings(importNode); + } + return undefined; +} + +export function extractTsNamedBindings(importNode: any): { local: string; exported: string }[] | undefined { + // import_statement > import_clause > named_imports > import_specifier* + const importClause = findChild(importNode, 'import_clause'); + if (importClause) { + const namedImports = findChild(importClause, 'named_imports'); + if (!namedImports) return undefined; // default import, namespace import, or side-effect + + const bindings: { local: string; exported: string }[] = []; + for (let i = 0; i < namedImports.namedChildCount; i++) { + const specifier = namedImports.namedChild(i); + if (specifier?.type !== 'import_specifier') continue; + + const identifiers: string[] = []; + for (let j = 0; j < specifier.namedChildCount; j++) { + const child = specifier.namedChild(j); + if (child?.type === 'identifier') identifiers.push(child.text); + } + + if (identifiers.length === 1) { + bindings.push({ local: identifiers[0], exported: identifiers[0] }); + } else if (identifiers.length === 2) { + // import { Foo as Bar } → exported='Foo', local='Bar' + bindings.push({ local: identifiers[1], exported: identifiers[0] }); + } + } + return bindings.length > 0 ? bindings : undefined; + } + + // Re-export: export { X } from './y' → export_statement > export_clause > export_specifier + const exportClause = findChild(importNode, 'export_clause'); + if (exportClause) { + const bindings: { local: string; exported: string }[] = []; + for (let i = 0; i < exportClause.namedChildCount; i++) { + const specifier = exportClause.namedChild(i); + if (specifier?.type !== 'export_specifier') continue; + + const identifiers: string[] = []; + for (let j = 0; j < specifier.namedChildCount; j++) { + const child = specifier.namedChild(j); + if (child?.type === 'identifier') identifiers.push(child.text); + } + + if (identifiers.length === 1) { + // export { User } from './base' → re-exports User as User + bindings.push({ local: identifiers[0], exported: identifiers[0] }); + } else if (identifiers.length === 2) { + // export { Repo as Repository } from './models' → name=Repo, alias=Repository + // For re-exports, the first id is the source name, second is what's exported + // When another file imports { Repository }, they get Repo from the source + bindings.push({ local: identifiers[1], exported: identifiers[0] }); + } + } + return bindings.length > 0 ? bindings : undefined; + } + + return undefined; +} + +export function extractPythonNamedBindings(importNode: any): { local: string; exported: string }[] | undefined { + // Only from import_from_statement, not plain import_statement + if (importNode.type !== 'import_from_statement') return undefined; + + const bindings: { local: string; exported: string }[] = []; + for (let i = 0; i < importNode.namedChildCount; i++) { + const child = importNode.namedChild(i); + if (!child) continue; + + if (child.type === 'dotted_name') { + // Skip the module_name (first dotted_name is the source module) + const fieldName = importNode.childForFieldName?.('module_name'); + if (fieldName && child.startIndex === fieldName.startIndex) continue; + + // This is an imported name: from x import User + const name = child.text; + if (name) bindings.push({ local: name, exported: name }); + } + + if (child.type === 'aliased_import') { + // from x import Repo as R + const dottedName = findChild(child, 'dotted_name'); + const aliasIdent = findChild(child, 'identifier'); + if (dottedName && aliasIdent) { + bindings.push({ local: aliasIdent.text, exported: dottedName.text }); + } + } + } + + return bindings.length > 0 ? bindings : undefined; +} + +export function extractKotlinNamedBindings(importNode: any): { local: string; exported: string }[] | undefined { + // import_header > identifier + import_alias > simple_identifier + if (importNode.type !== 'import_header') return undefined; + + const fullIdent = findChild(importNode, 'identifier'); + if (!fullIdent) return undefined; + + const fullText = fullIdent.text; + const exportedName = fullText.includes('.') ? fullText.split('.').pop()! : fullText; + + const importAlias = findChild(importNode, 'import_alias'); + if (importAlias) { + // Aliased: import com.example.User as U + const aliasIdent = findChild(importAlias, 'simple_identifier'); + if (!aliasIdent) return undefined; + return [{ local: aliasIdent.text, exported: exportedName }]; + } + + // Non-aliased: import com.example.User → local="User", exported="User" + // Skip wildcard imports (ending in *) + if (fullText.endsWith('.*') || fullText.endsWith('*')) return undefined; + // Skip lowercase last segments — those are member/function imports (e.g., + // import util.OneArg.writeAudit), not class imports. Multiple member imports + // with the same function name would collide in NamedImportMap, breaking + // arity-based disambiguation. + if (exportedName[0] && exportedName[0] === exportedName[0].toLowerCase()) return undefined; + return [{ local: exportedName, exported: exportedName }]; +} + +export function extractRustNamedBindings(importNode: any): { local: string; exported: string }[] | undefined { + // use_declaration may contain use_as_clause at any depth + if (importNode.type !== 'use_declaration') return undefined; + + const bindings: { local: string; exported: string }[] = []; + collectRustBindings(importNode, bindings); + return bindings.length > 0 ? bindings : undefined; +} + +function collectRustBindings(node: any, bindings: { local: string; exported: string }[]): void { + if (node.type === 'use_as_clause') { + // First identifier = exported name, second identifier = local alias + const idents: string[] = []; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === 'identifier') idents.push(child.text); + // For scoped_identifier, extract the last segment + if (child?.type === 'scoped_identifier') { + const nameNode = child.childForFieldName?.('name'); + if (nameNode) idents.push(nameNode.text); + } + } + if (idents.length === 2) { + bindings.push({ local: idents[1], exported: idents[0] }); + } + return; + } + + // Terminal identifier in a use_list: use crate::models::{User, Repo} + if (node.type === 'identifier' && node.parent?.type === 'use_list') { + bindings.push({ local: node.text, exported: node.text }); + return; + } + + // Skip scoped_identifier that serves as path prefix in scoped_use_list + // e.g. use crate::models::{User, Repo} — the path node "crate::models" is not an importable symbol + if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') { + return; // path prefix — the use_list sibling handles the actual symbols + } + + // Terminal scoped_identifier: use crate::models::User; + // Only extract if this is a leaf (no deeper use_list/use_as_clause/scoped_use_list) + if (node.type === 'scoped_identifier') { + let hasDeeper = false; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === 'use_list' || child?.type === 'use_as_clause' || child?.type === 'scoped_use_list') { + hasDeeper = true; + break; + } + } + if (!hasDeeper) { + const nameNode = node.childForFieldName?.('name'); + if (nameNode) { + bindings.push({ local: nameNode.text, exported: nameNode.text }); + } + return; + } + } + + // Recurse into children + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child) collectRustBindings(child, bindings); + } +} + +export function extractPhpNamedBindings(importNode: any): { local: string; exported: string }[] | undefined { + // namespace_use_declaration > namespace_use_clause* (flat) + // namespace_use_declaration > namespace_use_group > namespace_use_clause* (grouped) + if (importNode.type !== 'namespace_use_declaration') return undefined; + + const bindings: { local: string; exported: string }[] = []; + + // Collect all clauses — from direct children AND from namespace_use_group + const clauses: any[] = []; + for (let i = 0; i < importNode.namedChildCount; i++) { + const child = importNode.namedChild(i); + if (child?.type === 'namespace_use_clause') { + clauses.push(child); + } else if (child?.type === 'namespace_use_group') { + for (let j = 0; j < child.namedChildCount; j++) { + const groupChild = child.namedChild(j); + if (groupChild?.type === 'namespace_use_clause') clauses.push(groupChild); + } + } + } + + for (const clause of clauses) { + // Flat imports: qualified_name + name (alias) + let qualifiedName: any = null; + const names: any[] = []; + for (let j = 0; j < clause.namedChildCount; j++) { + const child = clause.namedChild(j); + if (child?.type === 'qualified_name') qualifiedName = child; + else if (child?.type === 'name') names.push(child); + } + + if (qualifiedName && names.length > 0) { + // Flat aliased import: use App\Models\Repo as R; + const fullText = qualifiedName.text; + const exportedName = fullText.includes('\\') ? fullText.split('\\').pop()! : fullText; + bindings.push({ local: names[0].text, exported: exportedName }); + } else if (qualifiedName && names.length === 0) { + // Flat non-aliased import: use App\Models\User; + const fullText = qualifiedName.text; + const lastSegment = fullText.includes('\\') ? fullText.split('\\').pop()! : fullText; + bindings.push({ local: lastSegment, exported: lastSegment }); + } else if (!qualifiedName && names.length >= 2) { + // Grouped aliased import: {Repo as R} — first name = exported, second = alias + bindings.push({ local: names[1].text, exported: names[0].text }); + } else if (!qualifiedName && names.length === 1) { + // Grouped non-aliased import: {User} in use App\Models\{User, Repo as R} + bindings.push({ local: names[0].text, exported: names[0].text }); + } + } + return bindings.length > 0 ? bindings : undefined; +} + +export function extractCsharpNamedBindings(importNode: any): { local: string; exported: string }[] | undefined { + // using_directive with identifier (alias) + qualified_name (target) + if (importNode.type !== 'using_directive') return undefined; + + let aliasIdent: any = null; + let qualifiedName: any = null; + for (let i = 0; i < importNode.namedChildCount; i++) { + const child = importNode.namedChild(i); + if (child?.type === 'identifier' && !aliasIdent) aliasIdent = child; + else if (child?.type === 'qualified_name') qualifiedName = child; + } + + if (!aliasIdent || !qualifiedName) return undefined; + + const fullText = qualifiedName.text; + const exportedName = fullText.includes('.') ? fullText.split('.').pop()! : fullText; + + return [{ local: aliasIdent.text, exported: exportedName }]; +} + +export function extractJavaNamedBindings(importNode: any): { local: string; exported: string }[] | undefined { + // import_declaration > scoped_identifier "com.example.models.User" + // Wildcard imports (.*) don't produce named bindings + if (importNode.type !== 'import_declaration') return undefined; + + // Check for asterisk (wildcard import) — skip those + for (let i = 0; i < importNode.childCount; i++) { + const child = importNode.child(i); + if (child?.type === 'asterisk') return undefined; + } + + const scopedId = findChild(importNode, 'scoped_identifier'); + if (!scopedId) return undefined; + + const fullText = scopedId.text; + const lastDot = fullText.lastIndexOf('.'); + if (lastDot === -1) return undefined; + + const className = fullText.slice(lastDot + 1); + // Skip lowercase names — those are package imports, not class imports + if (className[0] && className[0] === className[0].toLowerCase()) return undefined; + + return [{ local: className, exported: className }]; +} + +function findChild(node: any, type: string): any { + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === type) return child; + } + return null; +} diff --git a/gitnexus/src/core/ingestion/parsing-processor.ts b/gitnexus/src/core/ingestion/parsing-processor.ts index e7bb344a4b..b116e84521 100644 --- a/gitnexus/src/core/ingestion/parsing-processor.ts +++ b/gitnexus/src/core/ingestion/parsing-processor.ts @@ -1,123 +1,34 @@ -import { KnowledgeGraph, GraphNode, GraphRelationship } from '../graph/types.js'; +import { KnowledgeGraph, GraphNode, GraphRelationship, type NodeLabel } from '../graph/types.js'; import Parser from 'tree-sitter'; -import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js'; +import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js'; import { LANGUAGE_QUERIES } from './tree-sitter-queries.js'; import { generateId } from '../../lib/utils.js'; import { SymbolTable } from './symbol-table.js'; import { ASTCache } from './ast-cache.js'; -import { getLanguageFromFilename, yieldToEventLoop } from './utils.js'; +import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js'; +import { extractPropertyDeclaredType } from './type-extractors/shared.js'; +import { isNodeExported } from './export-detection.js'; +import { detectFrameworkFromAST } from './framework-detection.js'; +import { typeConfigs } from './type-extractors/index.js'; +import { SupportedLanguages } from '../../config/supported-languages.js'; import { WorkerPool } from './workers/worker-pool.js'; -import type { ParseWorkerResult, ParseWorkerInput, ExtractedImport, ExtractedCall, ExtractedHeritage } from './workers/parse-worker.js'; +import type { ParseWorkerResult, ParseWorkerInput, ExtractedImport, ExtractedCall, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js'; +import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js'; export type FileProgressCallback = (current: number, total: number, filePath: string) => void; export interface WorkerExtractedData { imports: ExtractedImport[]; calls: ExtractedCall[]; + assignments: ExtractedAssignment[]; heritage: ExtractedHeritage[]; + routes: ExtractedRoute[]; + constructorBindings: FileConstructorBindings[]; } -// ============================================================================ -// EXPORT DETECTION - Language-specific visibility detection -// ============================================================================ - -/** - * Check if a symbol (function, class, etc.) is exported/public - * Handles all 9 supported languages with explicit logic - * - * @param node - The AST node for the symbol name - * @param name - The symbol name - * @param language - The programming language - * @returns true if the symbol is exported/public - */ -const isNodeExported = (node: any, name: string, language: string): boolean => { - let current = node; - - switch (language) { - // JavaScript/TypeScript: Check for export keyword in ancestors - case 'javascript': - case 'typescript': - while (current) { - const type = current.type; - if (type === 'export_statement' || - type === 'export_specifier' || - type === 'lexical_declaration' && current.parent?.type === 'export_statement') { - return true; - } - // Also check if text starts with 'export ' - if (current.text?.startsWith('export ')) { - return true; - } - current = current.parent; - } - return false; - - // Python: Public if no leading underscore (convention) - case 'python': - return !name.startsWith('_'); - - // Java: Check for 'public' modifier - // In tree-sitter Java, modifiers are siblings of the name node, not parents - case 'java': - while (current) { - // Check if this node or any sibling is a 'modifiers' node containing 'public' - if (current.parent) { - const parent = current.parent; - // Check all children of the parent for modifiers - for (let i = 0; i < parent.childCount; i++) { - const child = parent.child(i); - if (child?.type === 'modifiers' && child.text?.includes('public')) { - return true; - } - } - // Also check if the parent's text starts with 'public' (fallback) - if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') { - if (parent.text?.trimStart().startsWith('public')) { - return true; - } - } - } - current = current.parent; - } - return false; - - // C#: Check for 'public' modifier in ancestors - case 'csharp': - while (current) { - if (current.type === 'modifier' || current.type === 'modifiers') { - if (current.text?.includes('public')) return true; - } - current = current.parent; - } - return false; - - // Go: Uppercase first letter = exported - case 'go': - if (name.length === 0) return false; - const first = name[0]; - // Must be uppercase letter (not a number or symbol) - return first === first.toUpperCase() && first !== first.toLowerCase(); - - // Rust: Check for 'pub' visibility modifier - case 'rust': - while (current) { - if (current.type === 'visibility_modifier') { - if (current.text?.includes('pub')) return true; - } - current = current.parent; - } - return false; - - // C/C++: No native export concept at language level - // Entry points will be detected via name patterns (main, etc.) - case 'c': - case 'cpp': - return false; - - default: - return false; - } -}; +// isNodeExported imported from ./export-detection.js (shared module) +// Re-export for backward compatibility with any external consumers +export { isNodeExported } from './export-detection.js'; // ============================================================================ // Worker-based parallel parsing @@ -129,34 +40,34 @@ const processParsingWithWorkers = async ( symbolTable: SymbolTable, astCache: ASTCache, workerPool: WorkerPool, - onFileProgress?: FileProgressCallback + onFileProgress?: FileProgressCallback, ): Promise<WorkerExtractedData> => { // Filter to parseable files only const parseableFiles: ParseWorkerInput[] = []; for (const file of files) { const lang = getLanguageFromFilename(file.path); - if (lang) { - parseableFiles.push({ path: file.path, content: file.content }); - } + if (lang) parseableFiles.push({ path: file.path, content: file.content }); } - if (parseableFiles.length === 0) return { imports: [], calls: [], heritage: [] }; + if (parseableFiles.length === 0) return { imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [] }; const total = files.length; - // Dispatch to worker pool — pool handles splitting into chunks - // Workers send progress messages during parsing so the bar updates smoothly + // Dispatch to worker pool — pool handles splitting into chunks and sub-batching const chunkResults = await workerPool.dispatch<ParseWorkerInput, ParseWorkerResult>( parseableFiles, (filesProcessed) => { onFileProgress?.(Math.min(filesProcessed, total), total, 'Parsing...'); - } + }, ); // Merge results from all workers into graph and symbol table const allImports: ExtractedImport[] = []; const allCalls: ExtractedCall[] = []; + const allAssignments: ExtractedAssignment[] = []; const allHeritage: ExtractedHeritage[] = []; + const allRoutes: ExtractedRoute[] = []; + const allConstructorBindings: FileConstructorBindings[] = []; for (const result of chunkResults) { for (const node of result.nodes) { graph.addNode({ @@ -171,17 +82,39 @@ const processParsingWithWorkers = async ( } for (const sym of result.symbols) { - symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type); + symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, { + parameterCount: sym.parameterCount, + returnType: sym.returnType, + declaredType: sym.declaredType, + ownerId: sym.ownerId, + }); } allImports.push(...result.imports); allCalls.push(...result.calls); + allAssignments.push(...result.assignments); allHeritage.push(...result.heritage); + allRoutes.push(...result.routes); + allConstructorBindings.push(...result.constructorBindings); + } + + // Merge and log skipped languages from workers + const skippedLanguages = new Map<string, number>(); + for (const result of chunkResults) { + for (const [lang, count] of Object.entries(result.skippedLanguages)) { + skippedLanguages.set(lang, (skippedLanguages.get(lang) || 0) + count); + } + } + if (skippedLanguages.size > 0) { + const summary = Array.from(skippedLanguages.entries()) + .map(([lang, count]) => `${lang}: ${count}`) + .join(', '); + console.warn(` Skipped unsupported languages: ${summary}`); } // Final progress onFileProgress?.(total, total, 'done'); - return { imports: allImports, calls: allCalls, heritage: allHeritage }; + return { imports: allImports, calls: allCalls, assignments: allAssignments, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings }; }; // ============================================================================ @@ -197,6 +130,7 @@ const processParsingSequential = async ( ) => { const parser = await loadParser(); const total = files.length; + const skippedLanguages = new Map<string, number>(); for (let i = 0; i < files.length; i++) { const file = files[i]; @@ -209,14 +143,24 @@ const processParsingSequential = async ( if (!language) continue; - // Skip very large files — they can crash tree-sitter or cause OOM - if (file.content.length > 512 * 1024) continue; + // Skip unsupported languages (e.g. Swift when tree-sitter-swift not installed) + if (!isLanguageAvailable(language)) { + skippedLanguages.set(language, (skippedLanguages.get(language) || 0) + 1); + continue; + } - await loadLanguage(language, file.path); + // Skip files larger than the max tree-sitter buffer (32 MB) + if (file.content.length > TREE_SITTER_MAX_BUFFER) continue; + + try { + await loadLanguage(language, file.path); + } catch { + continue; // parser unavailable — safety net + } let tree; try { - tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 }); + tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) }); } catch (parseError) { console.warn(`Skipping unparseable file: ${file.path}`); continue; @@ -256,13 +200,28 @@ const processParsingSequential = async ( } const nameNode = captureMap['name']; - if (!nameNode) return; + // Synthesize name for constructors without explicit @name capture (e.g. Swift init) + if (!nameNode && !captureMap['definition.constructor']) return; + const nodeName = nameNode ? nameNode.text : 'init'; - const nodeName = nameNode.text; + let nodeLabel: NodeLabel = 'CodeElement'; - let nodeLabel = 'CodeElement'; - - if (captureMap['definition.function']) nodeLabel = 'Function'; + if (captureMap['definition.function']) { + // C/C++: @definition.function is broad and also matches inline class methods (inside + // a class/struct body). Those are already captured by @definition.method, so skip + // the duplicate Function entry to prevent double-indexing in globalIndex. + if (language === SupportedLanguages.CPlusPlus || language === SupportedLanguages.C) { + let ancestor = captureMap['definition.function']?.parent; + while (ancestor) { + if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier') { + break; + } + ancestor = ancestor.parent; + } + if (ancestor) return; // inside a class body — handled by @definition.method + } + nodeLabel = 'Function'; + } else if (captureMap['definition.class']) nodeLabel = 'Class'; else if (captureMap['definition.interface']) nodeLabel = 'Interface'; else if (captureMap['definition.method']) nodeLabel = 'Method'; @@ -285,24 +244,69 @@ const processParsingSequential = async ( else if (captureMap['definition.constructor']) nodeLabel = 'Constructor'; else if (captureMap['definition.template']) nodeLabel = 'Template'; + const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap); + const startLine = definitionNodeForRange ? definitionNodeForRange.startPosition.row : (nameNode ? nameNode.startPosition.row : 0); const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`); + const definitionNode = getDefinitionNodeFromCaptures(captureMap); + const frameworkHint = definitionNode + ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300)) + : null; + + // Extract method signature for Method/Constructor nodes + const methodSig = (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor') + ? extractMethodSignature(definitionNode) + : undefined; + + // Language-specific return type fallback (e.g. Ruby YARD @return [Type]) + // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]` + if (methodSig && (!methodSig.returnType || methodSig.returnType === 'array' || methodSig.returnType === 'iterable') && definitionNode) { + const tc = typeConfigs[language as keyof typeof typeConfigs]; + if (tc?.extractReturnType) { + const docReturn = tc.extractReturnType(definitionNode); + if (docReturn) methodSig.returnType = docReturn; + } + } + const node: GraphNode = { id: nodeId, label: nodeLabel as any, properties: { name: nodeName, filePath: file.path, - startLine: nameNode.startPosition.row, - endLine: nameNode.endPosition.row, + startLine: definitionNodeForRange ? definitionNodeForRange.startPosition.row : startLine, + endLine: definitionNodeForRange ? definitionNodeForRange.endPosition.row : startLine, language: language, - isExported: isNodeExported(nameNode, nodeName, language), - } + isExported: isNodeExported(nameNode || definitionNodeForRange, nodeName, language), + ...(frameworkHint ? { + astFrameworkMultiplier: frameworkHint.entryPointMultiplier, + astFrameworkReason: frameworkHint.reason, + } : {}), + ...(methodSig ? { + parameterCount: methodSig.parameterCount, + returnType: methodSig.returnType, + } : {}), + }, }; graph.addNode(node); - symbolTable.add(file.path, nodeName, nodeId, nodeLabel); + // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD + // Function is included because Kotlin/Rust/Python capture class methods as Function nodes + const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function'; + const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null; + + // Extract declared type for Property nodes (field/property type annotations) + const declaredType = (nodeLabel === 'Property' && definitionNode) + ? extractPropertyDeclaredType(definitionNode) + : undefined; + + symbolTable.add(file.path, nodeName, nodeId, nodeLabel, { + parameterCount: methodSig?.parameterCount, + returnType: methodSig?.returnType, + declaredType, + ownerId: enclosingClassId ?? undefined, + }); const fileId = generateId('File', file.path); @@ -318,8 +322,28 @@ const processParsingSequential = async ( }; graph.addRelationship(relationship); + + // ── HAS_METHOD / HAS_PROPERTY: link member to enclosing class ── + if (enclosingClassId) { + const memberEdgeType = nodeLabel === 'Property' ? 'HAS_PROPERTY' : 'HAS_METHOD'; + graph.addRelationship({ + id: generateId(memberEdgeType, `${enclosingClassId}->${nodeId}`), + sourceId: enclosingClassId, + targetId: nodeId, + type: memberEdgeType, + confidence: 1.0, + reason: '', + }); + } }); } + + if (skippedLanguages.size > 0) { + const summary = Array.from(skippedLanguages.entries()) + .map(([lang, count]) => `${lang}: ${count}`) + .join(', '); + console.warn(` Skipped unsupported languages: ${summary}`); + } }; // ============================================================================ diff --git a/gitnexus/src/core/ingestion/pipeline.ts b/gitnexus/src/core/ingestion/pipeline.ts index d87aebf525..dc2d4658b8 100644 --- a/gitnexus/src/core/ingestion/pipeline.ts +++ b/gitnexus/src/core/ingestion/pipeline.ts @@ -1,43 +1,67 @@ import { createKnowledgeGraph } from '../graph/graph.js'; import { processStructure } from './structure-processor.js'; import { processParsing } from './parsing-processor.js'; -import { processImports, processImportsFromExtracted, createImportMap } from './import-processor.js'; -import { processCalls, processCallsFromExtracted } from './call-processor.js'; +import { + processImports, + processImportsFromExtracted, + buildImportResolutionContext +} from './import-processor.js'; +import { processCalls, processCallsFromExtracted, processAssignmentsFromExtracted, processRoutesFromExtracted } from './call-processor.js'; import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js'; +import { computeMRO } from './mro-processor.js'; import { processCommunities } from './community-processor.js'; import { processProcesses } from './process-processor.js'; -import { createSymbolTable } from './symbol-table.js'; +import { createResolutionContext } from './resolution-context.js'; import { createASTCache } from './ast-cache.js'; import { PipelineProgress, PipelineResult } from '../../types/pipeline.js'; -import { walkRepository } from './filesystem-walker.js'; +import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js'; +import { getLanguageFromFilename } from './utils.js'; +import { isLanguageAvailable } from '../tree-sitter/parser-loader.js'; import { createWorkerPool, WorkerPool } from './workers/worker-pool.js'; +import fs from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath, pathToFileURL } from 'node:url'; const isDev = process.env.NODE_ENV === 'development'; +/** Max bytes of source content to load per parse chunk. Each chunk's source + + * parsed ASTs + extracted records + worker serialization overhead all live in + * memory simultaneously, so this must be conservative. 20MB source ≈ 200-400MB + * peak working memory per chunk after parse expansion. */ +const CHUNK_BYTE_BUDGET = 20 * 1024 * 1024; // 20MB + +/** Max AST trees to keep in LRU cache */ +const AST_CACHE_CAP = 50; + +export interface PipelineOptions { + /** Skip MRO, community detection, and process extraction for faster test runs. */ + skipGraphPhases?: boolean; +} + export const runPipelineFromRepo = async ( repoPath: string, - onProgress: (progress: PipelineProgress) => void + onProgress: (progress: PipelineProgress) => void, + options?: PipelineOptions, ): Promise<PipelineResult> => { const graph = createKnowledgeGraph(); - const fileContents = new Map<string, string>(); - const symbolTable = createSymbolTable(); - // AST cache sized after file scan — start with a placeholder, resize after we know file count - let astCache = createASTCache(50); - const importMap = createImportMap(); + const ctx = createResolutionContext(); + const symbolTable = ctx.symbols; + let astCache = createASTCache(AST_CACHE_CAP); const cleanup = () => { astCache.clear(); - symbolTable.clear(); + ctx.clear(); }; try { + // ── Phase 1: Scan paths only (no content read) ───────────────────── onProgress({ phase: 'extracting', percent: 0, message: 'Scanning repository...', }); - const files = await walkRepository(repoPath, (current, total, filePath) => { + const scannedFiles = await walkRepositoryPaths(repoPath, (current, total, filePath) => { const scanProgress = Math.round((current / total) * 15); onProgress({ phase: 'extracting', @@ -48,287 +72,416 @@ export const runPipelineFromRepo = async ( }); }); - files.forEach(f => fileContents.set(f.path, f.content)); - - // Resize AST cache to fit all files — avoids re-parsing in import/call/heritage phases - astCache = createASTCache(files.length); + const totalFiles = scannedFiles.length; onProgress({ phase: 'extracting', percent: 15, message: 'Repository scanned successfully', - stats: { filesProcessed: files.length, totalFiles: files.length, nodesCreated: graph.nodeCount }, + stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount }, }); + // ── Phase 2: Structure (paths only — no content needed) ──────────── onProgress({ phase: 'structure', percent: 15, message: 'Analyzing project structure...', - stats: { filesProcessed: 0, totalFiles: files.length, nodesCreated: graph.nodeCount }, + stats: { filesProcessed: 0, totalFiles, nodesCreated: graph.nodeCount }, }); - const filePaths = files.map(f => f.path); - processStructure(graph, filePaths); + const allPaths = scannedFiles.map(f => f.path); + processStructure(graph, allPaths); onProgress({ phase: 'structure', - percent: 30, + percent: 20, message: 'Project structure analyzed', - stats: { filesProcessed: files.length, totalFiles: files.length, nodesCreated: graph.nodeCount }, + stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount }, }); + // ── Phase 3+4: Chunked read + parse ──────────────────────────────── + // Group parseable files into byte-budget chunks so only ~20MB of source + // is in memory at a time. Each chunk is: read → parse → extract → free. + + const parseableScanned = scannedFiles.filter(f => { + const lang = getLanguageFromFilename(f.path); + return lang && isLanguageAvailable(lang); + }); + + // Warn about files skipped due to unavailable parsers + const skippedByLang = new Map<string, number>(); + for (const f of scannedFiles) { + const lang = getLanguageFromFilename(f.path); + if (lang && !isLanguageAvailable(lang)) { + skippedByLang.set(lang, (skippedByLang.get(lang) || 0) + 1); + } + } + for (const [lang, count] of skippedByLang) { + console.warn(`Skipping ${count} ${lang} file(s) — ${lang} parser not available (native binding may not have built). Try: npm rebuild tree-sitter-${lang}`); + } + + const totalParseable = parseableScanned.length; + + if (totalParseable === 0) { + onProgress({ + phase: 'parsing', + percent: 82, + message: 'No parseable files found — skipping parsing phase', + stats: { filesProcessed: 0, totalFiles: 0, nodesCreated: graph.nodeCount }, + }); + } + + // Build byte-budget chunks + const chunks: string[][] = []; + let currentChunk: string[] = []; + let currentBytes = 0; + for (const file of parseableScanned) { + if (currentChunk.length > 0 && currentBytes + file.size > CHUNK_BYTE_BUDGET) { + chunks.push(currentChunk); + currentChunk = []; + currentBytes = 0; + } + currentChunk.push(file.path); + currentBytes += file.size; + } + if (currentChunk.length > 0) chunks.push(currentChunk); + + const numChunks = chunks.length; + + if (isDev) { + const totalMB = parseableScanned.reduce((s, f) => s + f.size, 0) / (1024 * 1024); + console.log(`📂 Scan: ${totalFiles} paths, ${totalParseable} parseable (${totalMB.toFixed(0)}MB), ${numChunks} chunks @ ${CHUNK_BYTE_BUDGET / (1024 * 1024)}MB budget`); + } + onProgress({ phase: 'parsing', - percent: 30, - message: 'Parsing code definitions...', - stats: { filesProcessed: 0, totalFiles: files.length, nodesCreated: graph.nodeCount }, + percent: 20, + message: `Parsing ${totalParseable} files in ${numChunks} chunk${numChunks !== 1 ? 's' : ''}...`, + stats: { filesProcessed: 0, totalFiles: totalParseable, nodesCreated: graph.nodeCount }, }); - // Create worker pool for parallel parsing, with graceful fallback + // Don't spawn workers for tiny repos — overhead exceeds benefit + const MIN_FILES_FOR_WORKERS = 15; + const MIN_BYTES_FOR_WORKERS = 512 * 1024; + const totalBytes = parseableScanned.reduce((s, f) => s + f.size, 0); + + // Create worker pool once, reuse across chunks let workerPool: WorkerPool | undefined; - try { - const workerUrl = new URL('./workers/parse-worker.js', import.meta.url); - workerPool = createWorkerPool(workerUrl); - } catch (err) { - // Worker pool creation failed (e.g., single core) — sequential fallback + if (totalParseable >= MIN_FILES_FOR_WORKERS || totalBytes >= MIN_BYTES_FOR_WORKERS) { + try { + let workerUrl = new URL('./workers/parse-worker.js', import.meta.url); + // When running under vitest, import.meta.url points to src/ where no .js exists. + // Fall back to the compiled dist/ worker so the pool can spawn real worker threads. + const thisDir = fileURLToPath(new URL('.', import.meta.url)); + if (!fs.existsSync(fileURLToPath(workerUrl))) { + const distWorker = path.resolve(thisDir, '..', '..', '..', 'dist', 'core', 'ingestion', 'workers', 'parse-worker.js'); + if (fs.existsSync(distWorker)) { + workerUrl = pathToFileURL(distWorker) as URL; + } + } + workerPool = createWorkerPool(workerUrl); + } catch (err) { + if (isDev) console.warn('Worker pool creation failed, using sequential fallback:', (err as Error).message); + } } - let workerData: Awaited<ReturnType<typeof processParsing>> = null; + let filesParsedSoFar = 0; + + // AST cache sized for one chunk (sequential fallback uses it for import/call/heritage) + const maxChunkFiles = chunks.reduce((max, c) => Math.max(max, c.length), 0); + astCache = createASTCache(maxChunkFiles); + + // Build import resolution context once — suffix index, file lists, resolve cache. + // Reused across all chunks to avoid rebuilding O(files × path_depth) structures. + const importCtx = buildImportResolutionContext(allPaths); + const allPathObjects = allPaths.map(p => ({ path: p })); + + // Single-pass: parse + resolve imports/calls/heritage per chunk. + // Calls/heritage use the symbol table built so far (symbols from earlier chunks + // are already registered). This trades ~5% cross-chunk resolution accuracy for + // 200-400MB less memory — critical for Linux-kernel-scale repos. + const sequentialChunkPaths: string[][] = []; + try { - workerData = await processParsing(graph, files, symbolTable, astCache, (current, total, filePath) => { - const parsingProgress = 30 + ((current / total) * 40); - onProgress({ - phase: 'parsing', - percent: Math.round(parsingProgress), - message: 'Parsing code definitions...', - detail: filePath, - stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount }, - }); - }, workerPool); + for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) { + const chunkPaths = chunks[chunkIdx]; + + // Read content for this chunk only + const chunkContents = await readFileContents(repoPath, chunkPaths); + const chunkFiles = chunkPaths + .filter(p => chunkContents.has(p)) + .map(p => ({ path: p, content: chunkContents.get(p)! })); + + // Parse this chunk (workers or sequential fallback) + const chunkWorkerData = await processParsing( + graph, chunkFiles, symbolTable, astCache, + (current, _total, filePath) => { + const globalCurrent = filesParsedSoFar + current; + const parsingProgress = 20 + ((globalCurrent / totalParseable) * 62); + onProgress({ + phase: 'parsing', + percent: Math.round(parsingProgress), + message: `Parsing chunk ${chunkIdx + 1}/${numChunks}...`, + detail: filePath, + stats: { filesProcessed: globalCurrent, totalFiles: totalParseable, nodesCreated: graph.nodeCount }, + }); + }, + workerPool, + ); + + const chunkBasePercent = 20 + ((filesParsedSoFar / totalParseable) * 62); + + if (chunkWorkerData) { + // Imports + await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, ctx, (current, total) => { + onProgress({ + phase: 'parsing', + percent: Math.round(chunkBasePercent), + message: `Resolving imports (chunk ${chunkIdx + 1}/${numChunks})...`, + detail: `${current}/${total} files`, + stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount }, + }); + }, repoPath, importCtx); + // Calls + Heritage + Routes — resolve in parallel (no shared mutable state between them) + // This is safe because each writes disjoint relationship types into idempotent id-keyed Maps, + // and the single-threaded event loop prevents races between synchronous addRelationship calls. + await Promise.all([ + processCallsFromExtracted( + graph, + chunkWorkerData.calls, + ctx, + (current, total) => { + onProgress({ + phase: 'parsing', + percent: Math.round(chunkBasePercent), + message: `Resolving calls (chunk ${chunkIdx + 1}/${numChunks})...`, + detail: `${current}/${total} files`, + stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount }, + }); + }, + chunkWorkerData.constructorBindings, + ), + processHeritageFromExtracted( + graph, + chunkWorkerData.heritage, + ctx, + (current, total) => { + onProgress({ + phase: 'parsing', + percent: Math.round(chunkBasePercent), + message: `Resolving heritage (chunk ${chunkIdx + 1}/${numChunks})...`, + detail: `${current}/${total} records`, + stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount }, + }); + }, + ), + processRoutesFromExtracted( + graph, + chunkWorkerData.routes ?? [], + ctx, + (current, total) => { + onProgress({ + phase: 'parsing', + percent: Math.round(chunkBasePercent), + message: `Resolving routes (chunk ${chunkIdx + 1}/${numChunks})...`, + detail: `${current}/${total} routes`, + stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount }, + }); + }, + ), + ]); + // Process field write assignments (synchronous, runs after calls resolve) + if (chunkWorkerData.assignments?.length) { + processAssignmentsFromExtracted(graph, chunkWorkerData.assignments, ctx, chunkWorkerData.constructorBindings); + } + } else { + await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths); + sequentialChunkPaths.push(chunkPaths); + } + + filesParsedSoFar += chunkFiles.length; + + // Clear AST cache between chunks to free memory + astCache.clear(); + // chunkContents + chunkFiles + chunkWorkerData go out of scope → GC reclaims + } } finally { await workerPool?.terminate(); } - onProgress({ - phase: 'imports', - percent: 70, - message: 'Resolving imports...', - stats: { filesProcessed: 0, totalFiles: files.length, nodesCreated: graph.nodeCount }, - }); - - if (workerData) { - // Fast path: imports already extracted by workers, just resolve paths - await processImportsFromExtracted(graph, files, workerData.imports, importMap, (current, total) => { - const importProgress = 70 + ((current / total) * 12); - onProgress({ - phase: 'imports', - percent: Math.round(importProgress), - message: 'Resolving imports...', - stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount }, - }); - }, repoPath); - } else { - // Fallback: full parse + resolve (sequential path) - await processImports(graph, files, astCache, importMap, (current, total) => { - const importProgress = 70 + ((current / total) * 12); - onProgress({ - phase: 'imports', - percent: Math.round(importProgress), - message: 'Resolving imports...', - stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount }, - }); - }, repoPath); + // Sequential fallback chunks: re-read source for call/heritage resolution + for (const chunkPaths of sequentialChunkPaths) { + const chunkContents = await readFileContents(repoPath, chunkPaths); + const chunkFiles = chunkPaths + .filter(p => chunkContents.has(p)) + .map(p => ({ path: p, content: chunkContents.get(p)! })); + astCache = createASTCache(chunkFiles.length); + const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx); + await processHeritage(graph, chunkFiles, astCache, ctx); + if (rubyHeritage.length > 0) { + await processHeritageFromExtracted(graph, rubyHeritage, ctx); + } + astCache.clear(); } + // Log resolution cache stats if (isDev) { - const importsCount = graph.relationships.filter(r => r.type === 'IMPORTS').length; - console.log(`📊 Pipeline: After import phase, graph has ${importsCount} IMPORTS relationships (total: ${graph.relationshipCount})`); + const rcStats = ctx.getStats(); + const total = rcStats.cacheHits + rcStats.cacheMisses; + const hitRate = total > 0 ? ((rcStats.cacheHits / total) * 100).toFixed(1) : '0'; + console.log(`🔍 Resolution cache: ${rcStats.cacheHits} hits, ${rcStats.cacheMisses} misses (${hitRate}% hit rate)`); } - onProgress({ - phase: 'calls', - percent: 82, - message: 'Tracing function calls...', - stats: { filesProcessed: 0, totalFiles: files.length, nodesCreated: graph.nodeCount }, - }); + // Free import resolution context — suffix index + resolve cache no longer needed + // (allPathObjects and importCtx hold ~94MB+ for large repos) + allPathObjects.length = 0; + importCtx.resolveCache.clear(); + (importCtx as any).suffixIndex = null; + (importCtx as any).normalizedFileList = null; - if (workerData) { - // Fast path: calls already extracted by workers, just resolve targets - await processCallsFromExtracted(graph, workerData.calls, symbolTable, importMap, (current, total) => { - const callProgress = 82 + ((current / total) * 10); - onProgress({ - phase: 'calls', - percent: Math.round(callProgress), - message: 'Tracing function calls...', - stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount }, - }); + let communityResult: Awaited<ReturnType<typeof processCommunities>> | undefined; + let processResult: Awaited<ReturnType<typeof processProcesses>> | undefined; + + if (!options?.skipGraphPhases) { + // ── Phase 4.5: Method Resolution Order ────────────────────────────── + onProgress({ + phase: 'parsing', + percent: 81, + message: 'Computing method resolution order...', + stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount }, }); - } else { - // Fallback: full parse + resolve (sequential path) - await processCalls(graph, files, astCache, symbolTable, importMap, (current, total) => { - const callProgress = 82 + ((current / total) * 10); - onProgress({ - phase: 'calls', - percent: Math.round(callProgress), - message: 'Tracing function calls...', - stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount }, - }); - }); - } - onProgress({ - phase: 'heritage', - percent: 92, - message: 'Extracting class inheritance...', - stats: { filesProcessed: 0, totalFiles: files.length, nodesCreated: graph.nodeCount }, - }); + const mroResult = computeMRO(graph); + if (isDev && mroResult.entries.length > 0) { + console.log(`🔀 MRO: ${mroResult.entries.length} classes analyzed, ${mroResult.ambiguityCount} ambiguities found, ${mroResult.overrideEdges} OVERRIDES edges`); + } - if (workerData) { - // Fast path: heritage already extracted by workers, just resolve symbols - await processHeritageFromExtracted(graph, workerData.heritage, symbolTable, (current, total) => { - const heritageProgress = 88 + ((current / total) * 4); - onProgress({ - phase: 'heritage', - percent: Math.round(heritageProgress), - message: 'Extracting class inheritance...', - stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount }, - }); - }); - } else { - // Fallback: full parse + resolve (sequential path) - await processHeritage(graph, files, astCache, symbolTable, (current, total) => { - const heritageProgress = 88 + ((current / total) * 4); - onProgress({ - phase: 'heritage', - percent: Math.round(heritageProgress), - message: 'Extracting class inheritance...', - stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount }, - }); - }); - } - - onProgress({ - phase: 'communities', - percent: 92, - message: 'Detecting code communities...', - stats: { filesProcessed: files.length, totalFiles: files.length, nodesCreated: graph.nodeCount }, - }); - - const communityResult = await processCommunities(graph, (message, progress) => { - const communityProgress = 92 + (progress * 0.06); + // ── Phase 5: Communities ─────────────────────────────────────────── onProgress({ phase: 'communities', - percent: Math.round(communityProgress), - message, - stats: { filesProcessed: files.length, totalFiles: files.length, nodesCreated: graph.nodeCount }, + percent: 82, + message: 'Detecting code communities...', + stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount }, }); - }); - if (isDev) { - console.log(`🏘️ Community detection: ${communityResult.stats.totalCommunities} communities found (modularity: ${communityResult.stats.modularity.toFixed(3)})`); - } - - communityResult.communities.forEach(comm => { - graph.addNode({ - id: comm.id, - label: 'Community' as const, - properties: { - name: comm.label, - filePath: '', - heuristicLabel: comm.heuristicLabel, - cohesion: comm.cohesion, - symbolCount: comm.symbolCount, - } - }); - }); - - communityResult.memberships.forEach(membership => { - graph.addRelationship({ - id: `${membership.nodeId}_member_of_${membership.communityId}`, - type: 'MEMBER_OF', - sourceId: membership.nodeId, - targetId: membership.communityId, - confidence: 1.0, - reason: 'leiden-algorithm', - }); - }); - - onProgress({ - phase: 'processes', - percent: 98, - message: 'Detecting execution flows...', - stats: { filesProcessed: files.length, totalFiles: files.length, nodesCreated: graph.nodeCount }, - }); - - // Dynamic process cap based on codebase size - const symbolCount = graph.nodes.filter(n => n.label !== 'File').length; - const dynamicMaxProcesses = Math.max(20, Math.min(300, Math.round(symbolCount / 10))); - - const processResult = await processProcesses( - graph, - communityResult.memberships, - (message, progress) => { - const processProgress = 98 + (progress * 0.01); + communityResult = await processCommunities(graph, (message, progress) => { + const communityProgress = 82 + (progress * 0.10); onProgress({ - phase: 'processes', - percent: Math.round(processProgress), + phase: 'communities', + percent: Math.round(communityProgress), message, - stats: { filesProcessed: files.length, totalFiles: files.length, nodesCreated: graph.nodeCount }, + stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount }, }); - }, - { maxProcesses: dynamicMaxProcesses, minSteps: 3 } - ); + }); - if (isDev) { - console.log(`🔄 Process detection: ${processResult.stats.totalProcesses} processes found (${processResult.stats.crossCommunityCount} cross-community)`); + if (isDev) { + console.log(`🏘️ Community detection: ${communityResult.stats.totalCommunities} communities found (modularity: ${communityResult.stats.modularity.toFixed(3)})`); + } + + communityResult.communities.forEach(comm => { + graph.addNode({ + id: comm.id, + label: 'Community' as const, + properties: { + name: comm.label, + filePath: '', + heuristicLabel: comm.heuristicLabel, + cohesion: comm.cohesion, + symbolCount: comm.symbolCount, + } + }); + }); + + communityResult.memberships.forEach(membership => { + graph.addRelationship({ + id: `${membership.nodeId}_member_of_${membership.communityId}`, + type: 'MEMBER_OF', + sourceId: membership.nodeId, + targetId: membership.communityId, + confidence: 1.0, + reason: 'leiden-algorithm', + }); + }); + + // ── Phase 6: Processes ───────────────────────────────────────────── + onProgress({ + phase: 'processes', + percent: 94, + message: 'Detecting execution flows...', + stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount }, + }); + + let symbolCount = 0; + graph.forEachNode(n => { if (n.label !== 'File') symbolCount++; }); + const dynamicMaxProcesses = Math.max(20, Math.min(300, Math.round(symbolCount / 10))); + + processResult = await processProcesses( + graph, + communityResult.memberships, + (message, progress) => { + const processProgress = 94 + (progress * 0.05); + onProgress({ + phase: 'processes', + percent: Math.round(processProgress), + message, + stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount }, + }); + }, + { maxProcesses: dynamicMaxProcesses, minSteps: 3 } + ); + + if (isDev) { + console.log(`🔄 Process detection: ${processResult.stats.totalProcesses} processes found (${processResult.stats.crossCommunityCount} cross-community)`); + } + + processResult.processes.forEach(proc => { + graph.addNode({ + id: proc.id, + label: 'Process' as const, + properties: { + name: proc.label, + filePath: '', + heuristicLabel: proc.heuristicLabel, + processType: proc.processType, + stepCount: proc.stepCount, + communities: proc.communities, + entryPointId: proc.entryPointId, + terminalId: proc.terminalId, + } + }); + }); + + processResult.steps.forEach(step => { + graph.addRelationship({ + id: `${step.nodeId}_step_${step.step}_${step.processId}`, + type: 'STEP_IN_PROCESS', + sourceId: step.nodeId, + targetId: step.processId, + confidence: 1.0, + reason: 'trace-detection', + step: step.step, + }); + }); } - processResult.processes.forEach(proc => { - graph.addNode({ - id: proc.id, - label: 'Process' as const, - properties: { - name: proc.label, - filePath: '', - heuristicLabel: proc.heuristicLabel, - processType: proc.processType, - stepCount: proc.stepCount, - communities: proc.communities, - entryPointId: proc.entryPointId, - terminalId: proc.terminalId, - } - }); - }); - - processResult.steps.forEach(step => { - graph.addRelationship({ - id: `${step.nodeId}_step_${step.step}_${step.processId}`, - type: 'STEP_IN_PROCESS', - sourceId: step.nodeId, - targetId: step.processId, - confidence: 1.0, - reason: 'trace-detection', - step: step.step, - }); - }); - onProgress({ phase: 'complete', percent: 100, - message: `Graph complete! ${communityResult.stats.totalCommunities} communities, ${processResult.stats.totalProcesses} processes detected.`, + message: communityResult && processResult + ? `Graph complete! ${communityResult.stats.totalCommunities} communities, ${processResult.stats.totalProcesses} processes detected.` + : 'Graph complete! (graph phases skipped)', stats: { - filesProcessed: files.length, - totalFiles: files.length, + filesProcessed: totalFiles, + totalFiles, nodesCreated: graph.nodeCount }, }); astCache.clear(); - return { graph, fileContents, communityResult, processResult }; + return { graph, repoPath, totalFileCount: totalFiles, communityResult, processResult }; } catch (error) { cleanup(); throw error; } }; - diff --git a/gitnexus/src/core/ingestion/process-processor.ts b/gitnexus/src/core/ingestion/process-processor.ts index 10d3261fbd..ab77ee1873 100644 --- a/gitnexus/src/core/ingestion/process-processor.ts +++ b/gitnexus/src/core/ingestion/process-processor.ts @@ -13,6 +13,7 @@ import { KnowledgeGraph, GraphNode, GraphRelationship, NodeLabel } from '../graph/types.js'; import { CommunityMembership } from './community-processor.js'; import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js'; +import { SupportedLanguages } from '../../config/supported-languages.js'; const isDev = process.env.NODE_ENV === 'development'; @@ -93,7 +94,7 @@ export const processProcesses = async ( const callsEdges = buildCallsGraph(knowledgeGraph); const reverseCallsEdges = buildReverseCallsGraph(knowledgeGraph); const nodeMap = new Map<string, GraphNode>(); - knowledgeGraph.nodes.forEach(n => nodeMap.set(n.id, n)); + for (const n of knowledgeGraph.iterNodes()) nodeMap.set(n.id, n); // Step 1: Find entry points (functions that call others but have few callers) const entryPoints = findEntryPoints(knowledgeGraph, reverseCallsEdges, callsEdges); @@ -221,29 +222,29 @@ const MIN_TRACE_CONFIDENCE = 0.5; const buildCallsGraph = (graph: KnowledgeGraph): AdjacencyList => { const adj = new Map<string, string[]>(); - graph.relationships.forEach(rel => { + for (const rel of graph.iterRelationships()) { if (rel.type === 'CALLS' && rel.confidence >= MIN_TRACE_CONFIDENCE) { if (!adj.has(rel.sourceId)) { adj.set(rel.sourceId, []); } adj.get(rel.sourceId)!.push(rel.targetId); } - }); - + } + return adj; }; const buildReverseCallsGraph = (graph: KnowledgeGraph): AdjacencyList => { const adj = new Map<string, string[]>(); - - graph.relationships.forEach(rel => { + + for (const rel of graph.iterRelationships()) { if (rel.type === 'CALLS' && rel.confidence >= MIN_TRACE_CONFIDENCE) { if (!adj.has(rel.targetId)) { adj.set(rel.targetId, []); } adj.get(rel.targetId)!.push(rel.sourceId); } - }); + } return adj; }; @@ -270,34 +271,41 @@ const findEntryPoints = ( reasons: string[]; }[] = []; - graph.nodes.forEach(node => { - if (!symbolTypes.has(node.label)) return; + for (const node of graph.iterNodes()) { + if (!symbolTypes.has(node.label)) continue; const filePath = node.properties.filePath || ''; // Skip test files entirely - if (isTestFile(filePath)) return; - + if (isTestFile(filePath)) continue; + const callers = reverseCallsEdges.get(node.id) || []; const callees = callsEdges.get(node.id) || []; - + // Must have at least 1 outgoing call to trace forward - if (callees.length === 0) return; - + if (callees.length === 0) continue; + // Calculate entry point score using new scoring system - const { score, reasons } = calculateEntryPointScore( + const { score: baseScore, reasons } = calculateEntryPointScore( node.properties.name, - node.properties.language || 'javascript', + node.properties.language ?? SupportedLanguages.JavaScript, node.properties.isExported ?? false, callers.length, callees.length, filePath // Pass filePath for framework detection ); - + + let score = baseScore; + const astFrameworkMultiplier = node.properties.astFrameworkMultiplier ?? 1.0; + if (astFrameworkMultiplier > 1.0) { + score *= astFrameworkMultiplier; + reasons.push(`framework-ast:${node.properties.astFrameworkReason || 'decorator'}`); + } + if (score > 0) { entryPointCandidates.push({ id: node.id, score, reasons }); } - }); + } // Sort by score descending and return top candidates const sorted = entryPointCandidates.sort((a, b) => b.score - a.score); @@ -306,7 +314,7 @@ const findEntryPoints = ( if (sorted.length > 0 && isDev) { console.log(`[Process] Top 10 entry point candidates (new scoring):`); sorted.slice(0, 10).forEach((c, i) => { - const node = graph.nodes.find(n => n.id === c.id); + const node = graph.getNode(c.id); const exported = node?.properties.isExported ? '✓' : '✗'; const shortPath = node?.properties.filePath?.split('/').slice(-2).join('/') || ''; console.log(` ${i+1}. ${node?.properties.name} [exported:${exported}] (${shortPath})`); @@ -337,8 +345,7 @@ const traceFromEntryPoint = ( // BFS with path tracking // Each queue item: [currentNodeId, pathSoFar] const queue: [string, string[]][] = [[entryId, [entryId]]]; - const visited = new Set<string>(); - + while (queue.length > 0 && traces.length < config.maxBranching * 3) { const [currentId, path] = queue.shift()!; diff --git a/gitnexus/src/core/ingestion/resolution-context.ts b/gitnexus/src/core/ingestion/resolution-context.ts new file mode 100644 index 0000000000..bac5bfb947 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolution-context.ts @@ -0,0 +1,192 @@ +/** + * Resolution Context + * + * Single implementation of tiered name resolution. Replaces the duplicated + * tier-selection logic previously split between symbol-resolver.ts and + * call-processor.ts. + * + * Resolution tiers (highest confidence first): + * 1. Same file (lookupExactFull — authoritative) + * 2a-named. Named binding chain (walkBindingChain via NamedImportMap) + * 2a. Import-scoped (lookupFuzzy filtered by ImportMap) + * 2b. Package-scoped (lookupFuzzy filtered by PackageMap) + * 3. Global (all candidates — consumers must check candidate count) + */ + +import type { SymbolTable, SymbolDefinition } from './symbol-table.js'; +import { createSymbolTable } from './symbol-table.js'; +import type { NamedImportBinding } from './import-processor.js'; +import { isFileInPackageDir } from './import-processor.js'; +import { walkBindingChain } from './named-binding-extraction.js'; + +/** Resolution tier for tracking, logging, and test assertions. */ +export type ResolutionTier = 'same-file' | 'import-scoped' | 'global'; + +/** Tier-selected candidates with metadata. */ +export interface TieredCandidates { + readonly candidates: readonly SymbolDefinition[]; + readonly tier: ResolutionTier; +} + +/** Confidence scores per resolution tier. */ +export const TIER_CONFIDENCE: Record<ResolutionTier, number> = { + 'same-file': 0.95, + 'import-scoped': 0.9, + 'global': 0.5, +}; + +// --- Map types --- +export type ImportMap = Map<string, Set<string>>; +export type PackageMap = Map<string, Set<string>>; +export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>; + +export interface ResolutionContext { + /** + * The only resolution API. Returns all candidates at the winning tier. + * + * Tier 3 ('global') returns ALL candidates regardless of count — + * consumers must check candidates.length and refuse ambiguous matches. + */ + resolve(name: string, fromFile: string): TieredCandidates | null; + + // --- Data access (for pipeline wiring, not resolution) --- + /** Symbol table — used by parsing-processor to populate symbols. */ + readonly symbols: SymbolTable; + /** Raw maps — used by import-processor to populate import data. */ + readonly importMap: ImportMap; + readonly packageMap: PackageMap; + readonly namedImportMap: NamedImportMap; + + // --- Per-file cache lifecycle --- + enableCache(filePath: string): void; + clearCache(): void; + + // --- Operational --- + getStats(): { fileCount: number; globalSymbolCount: number; cacheHits: number; cacheMisses: number }; + clear(): void; +} + +export const createResolutionContext = (): ResolutionContext => { + const symbols = createSymbolTable(); + const importMap: ImportMap = new Map(); + const packageMap: PackageMap = new Map(); + const namedImportMap: NamedImportMap = new Map(); + + // Per-file cache state + let cacheFile: string | null = null; + let cache: Map<string, TieredCandidates | null> | null = null; + let cacheHits = 0; + let cacheMisses = 0; + + // --- Core resolution (single implementation of tier logic) --- + + const resolveUncached = (name: string, fromFile: string): TieredCandidates | null => { + // Tier 1: Same file — authoritative match + const localDef = symbols.lookupExactFull(fromFile, name); + if (localDef) { + return { candidates: [localDef], tier: 'same-file' }; + } + + // Get all global definitions for subsequent tiers + const allDefs = symbols.lookupFuzzy(name); + + // Tier 2a-named: Check named bindings BEFORE empty-allDefs early return + // because aliased imports mean lookupFuzzy('U') returns empty but we + // can resolve via the exported name. + const chainResult = walkBindingChain(name, fromFile, symbols, namedImportMap, allDefs); + if (chainResult && chainResult.length > 0) { + return { candidates: chainResult, tier: 'import-scoped' }; + } + + if (allDefs.length === 0) return null; + + // Tier 2a: Import-scoped — definition in a file imported by fromFile + const importedFiles = importMap.get(fromFile); + if (importedFiles) { + const importedDefs = allDefs.filter(def => importedFiles.has(def.filePath)); + if (importedDefs.length > 0) { + return { candidates: importedDefs, tier: 'import-scoped' }; + } + } + + // Tier 2b: Package-scoped — definition in a package dir imported by fromFile + const importedPackages = packageMap.get(fromFile); + if (importedPackages) { + const packageDefs = allDefs.filter(def => { + for (const dirSuffix of importedPackages) { + if (isFileInPackageDir(def.filePath, dirSuffix)) return true; + } + return false; + }); + if (packageDefs.length > 0) { + return { candidates: packageDefs, tier: 'import-scoped' }; + } + } + + // Tier 3: Global — pass all candidates through. + // Consumers must check candidate count and refuse ambiguous matches. + return { candidates: allDefs, tier: 'global' }; + }; + + const resolve = (name: string, fromFile: string): TieredCandidates | null => { + // Check cache (only when enabled AND fromFile matches cached file) + if (cache && cacheFile === fromFile) { + if (cache.has(name)) { + cacheHits++; + return cache.get(name)!; + } + cacheMisses++; + } + + const result = resolveUncached(name, fromFile); + + // Store in cache if active and file matches + if (cache && cacheFile === fromFile) { + cache.set(name, result); + } + + return result; + }; + + // --- Cache lifecycle --- + + const enableCache = (filePath: string): void => { + cacheFile = filePath; + if (!cache) cache = new Map(); + else cache.clear(); + }; + + const clearCache = (): void => { + cacheFile = null; + // Reuse the Map instance — just clear entries to reduce GC pressure at scale. + cache?.clear(); + }; + + const getStats = () => ({ + ...symbols.getStats(), + cacheHits, + cacheMisses, + }); + + const clear = (): void => { + symbols.clear(); + importMap.clear(); + packageMap.clear(); + namedImportMap.clear(); + clearCache(); + cacheHits = 0; + cacheMisses = 0; + }; + + return { + resolve, + symbols, + importMap, + packageMap, + namedImportMap, + enableCache, + clearCache, + getStats, + clear, + }; +}; diff --git a/gitnexus/src/core/ingestion/resolvers/csharp.ts b/gitnexus/src/core/ingestion/resolvers/csharp.ts new file mode 100644 index 0000000000..e916456ae3 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/csharp.ts @@ -0,0 +1,128 @@ +/** + * C# namespace import resolution. + * Handles using-directive resolution via .csproj root namespace stripping. + */ + +import type { SuffixIndex } from './utils.js'; +import { suffixResolve } from './utils.js'; + +/** C# project config parsed from .csproj files */ +export interface CSharpProjectConfig { + /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */ + rootNamespace: string; + /** Directory containing the .csproj file */ + projectDir: string; +} + +/** + * Resolve a C# using-directive import path to matching .cs files. + * Tries single-file match first, then directory match for namespace imports. + */ +export function resolveCSharpImport( + importPath: string, + csharpConfigs: CSharpProjectConfig[], + normalizedFileList: string[], + allFileList: string[], + index?: SuffixIndex, +): string[] { + const namespacePath = importPath.replace(/\./g, '/'); + const results: string[] = []; + + for (const config of csharpConfigs) { + const nsPath = config.rootNamespace.replace(/\./g, '/'); + let relative: string; + if (namespacePath.startsWith(nsPath + '/')) { + relative = namespacePath.slice(nsPath.length + 1); + } else if (namespacePath === nsPath) { + // The import IS the root namespace — resolve to all .cs files in project root + relative = ''; + } else { + continue; + } + + const dirPrefix = config.projectDir + ? (relative ? config.projectDir + '/' + relative : config.projectDir) + : relative; + + // 1. Try as single file: relative.cs (e.g., "Models/DlqMessage.cs") + if (relative) { + const candidate = dirPrefix + '.cs'; + if (index) { + const result = index.get(candidate) || index.getInsensitive(candidate); + if (result) return [result]; + } + // Also try suffix match + const suffixResult = index?.get(relative + '.cs') || index?.getInsensitive(relative + '.cs'); + if (suffixResult) return [suffixResult]; + } + + // 2. Try as directory: all .cs files directly inside (namespace import) + if (index) { + const dirFiles = index.getFilesInDir(dirPrefix, '.cs'); + for (const f of dirFiles) { + const normalized = f.replace(/\\/g, '/'); + // Check it's a direct child by finding the dirPrefix and ensuring no deeper slashes + const prefixIdx = normalized.indexOf(dirPrefix + '/'); + if (prefixIdx < 0) continue; + const afterDir = normalized.substring(prefixIdx + dirPrefix.length + 1); + if (!afterDir.includes('/')) { + results.push(f); + } + } + if (results.length > 0) return results; + } + + // 3. Linear scan fallback for directory matching + if (results.length === 0) { + const dirTrail = dirPrefix + '/'; + for (let i = 0; i < normalizedFileList.length; i++) { + const normalized = normalizedFileList[i]; + if (!normalized.endsWith('.cs')) continue; + const prefixIdx = normalized.indexOf(dirTrail); + if (prefixIdx < 0) continue; + const afterDir = normalized.substring(prefixIdx + dirTrail.length); + if (!afterDir.includes('/')) { + results.push(allFileList[i]); + } + } + if (results.length > 0) return results; + } + } + + // Fallback: suffix matching without namespace stripping (single file) + const pathParts = namespacePath.split('/').filter(Boolean); + const fallback = suffixResolve(pathParts, normalizedFileList, allFileList, index); + return fallback ? [fallback] : []; +} + +/** + * Compute the directory suffix for a C# namespace import (for PackageMap). + * Returns a suffix like "/ProjectDir/Models/" or null if no config matches. + */ +export function resolveCSharpNamespaceDir( + importPath: string, + csharpConfigs: CSharpProjectConfig[], +): string | null { + const namespacePath = importPath.replace(/\./g, '/'); + + for (const config of csharpConfigs) { + const nsPath = config.rootNamespace.replace(/\./g, '/'); + let relative: string; + if (namespacePath.startsWith(nsPath + '/')) { + relative = namespacePath.slice(nsPath.length + 1); + } else if (namespacePath === nsPath) { + relative = ''; + } else { + continue; + } + + const dirPrefix = config.projectDir + ? (relative ? config.projectDir + '/' + relative : config.projectDir) + : relative; + + if (!dirPrefix) continue; + return '/' + dirPrefix + '/'; + } + + return null; +} diff --git a/gitnexus/src/core/ingestion/resolvers/go.ts b/gitnexus/src/core/ingestion/resolvers/go.ts new file mode 100644 index 0000000000..82f104b51a --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/go.ts @@ -0,0 +1,58 @@ +/** + * Go package import resolution. + * Handles Go module path-based package imports. + */ + +/** Go module config parsed from go.mod */ +export interface GoModuleConfig { + /** Module path (e.g., "github.com/user/repo") */ + modulePath: string; +} + +/** + * Extract the package directory suffix from a Go import path. + * Returns the suffix string (e.g., "/internal/auth/") or null if invalid. + */ +export function resolveGoPackageDir( + importPath: string, + goModule: GoModuleConfig, +): string | null { + if (!importPath.startsWith(goModule.modulePath)) return null; + const relativePkg = importPath.slice(goModule.modulePath.length + 1); + if (!relativePkg) return null; + return '/' + relativePkg + '/'; +} + +/** + * Resolve a Go internal package import to all .go files in the package directory. + * Returns an array of file paths. + */ +export function resolveGoPackage( + importPath: string, + goModule: GoModuleConfig, + normalizedFileList: string[], + allFileList: string[], +): string[] { + if (!importPath.startsWith(goModule.modulePath)) return []; + + // Strip module path to get relative package path + const relativePkg = importPath.slice(goModule.modulePath.length + 1); // e.g., "internal/auth" + if (!relativePkg) return []; + + const pkgSuffix = '/' + relativePkg + '/'; + const matches: string[] = []; + + for (let i = 0; i < normalizedFileList.length; i++) { + // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/" + const normalized = '/' + normalizedFileList[i]; + // File must be directly in the package directory (not a subdirectory) + if (normalized.includes(pkgSuffix) && normalized.endsWith('.go') && !normalized.endsWith('_test.go')) { + const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length); + if (!afterPkg.includes('/')) { + matches.push(allFileList[i]); + } + } + } + + return matches; +} diff --git a/gitnexus/src/core/ingestion/resolvers/index.ts b/gitnexus/src/core/ingestion/resolvers/index.ts new file mode 100644 index 0000000000..b31e535f93 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/index.ts @@ -0,0 +1,27 @@ +/** + * Language-specific import resolvers. + * Extracted from import-processor.ts for maintainability. + */ + +export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve } from './utils.js'; +export type { SuffixIndex } from './utils.js'; + +export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js'; + +export { resolveGoPackageDir, resolveGoPackage } from './go.js'; +export type { GoModuleConfig } from './go.js'; + +export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js'; +export type { CSharpProjectConfig } from './csharp.js'; + +export { resolvePhpImport } from './php.js'; +export type { ComposerConfig } from './php.js'; + +export { resolveRustImport, tryRustModulePath } from './rust.js'; + +export { resolveRubyImport } from './ruby.js'; + +export { resolvePythonImport } from './python.js'; + +export { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js'; +export type { TsconfigPaths } from './standard.js'; diff --git a/gitnexus/src/core/ingestion/resolvers/jvm.ts b/gitnexus/src/core/ingestion/resolvers/jvm.ts new file mode 100644 index 0000000000..5b532e47e8 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/jvm.ts @@ -0,0 +1,106 @@ +/** + * JVM import resolution (Java + Kotlin). + * Handles wildcard imports, member/static imports, and Kotlin-specific patterns. + */ + +import type { SuffixIndex } from './utils.js'; + +/** Kotlin file extensions for JVM resolver reuse */ +export const KOTLIN_EXTENSIONS: readonly string[] = ['.kt', '.kts']; + +/** + * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node. + * Pure function — returns a new string without mutating the input. + */ +export const appendKotlinWildcard = (importPath: string, importNode: any): string => { + for (let i = 0; i < importNode.childCount; i++) { + if (importNode.child(i)?.type === 'wildcard_import') { + return importPath.endsWith('.*') ? importPath : `${importPath}.*`; + } + } + return importPath; +}; + +/** + * Resolve a JVM wildcard import (com.example.*) to all matching files. + * Works for both Java (.java) and Kotlin (.kt, .kts). + */ +export function resolveJvmWildcard( + importPath: string, + normalizedFileList: string[], + allFileList: string[], + extensions: readonly string[], + index?: SuffixIndex, +): string[] { + // "com.example.util.*" -> "com/example/util" + const packagePath = importPath.slice(0, -2).replace(/\./g, '/'); + + if (index) { + const candidates = extensions.flatMap(ext => index.getFilesInDir(packagePath, ext)); + // Filter to only direct children (no subdirectories) + const packageSuffix = '/' + packagePath + '/'; + return candidates.filter(f => { + const normalized = f.replace(/\\/g, '/'); + const idx = normalized.indexOf(packageSuffix); + if (idx < 0) return false; + const afterPkg = normalized.substring(idx + packageSuffix.length); + return !afterPkg.includes('/'); + }); + } + + // Fallback: linear scan + const packageSuffix = '/' + packagePath + '/'; + const matches: string[] = []; + for (let i = 0; i < normalizedFileList.length; i++) { + const normalized = normalizedFileList[i]; + if (normalized.includes(packageSuffix) && + extensions.some(ext => normalized.endsWith(ext))) { + const afterPackage = normalized.substring(normalized.indexOf(packageSuffix) + packageSuffix.length); + if (!afterPackage.includes('/')) { + matches.push(allFileList[i]); + } + } + } + return matches; +} + +/** + * Try to resolve a JVM member/static import by stripping the member name. + * Java: "com.example.Constants.VALUE" -> resolve "com.example.Constants" + * Kotlin: "com.example.Constants.VALUE" -> resolve "com.example.Constants" + */ +export function resolveJvmMemberImport( + importPath: string, + normalizedFileList: string[], + allFileList: string[], + extensions: readonly string[], + index?: SuffixIndex, +): string | null { + // Member imports: com.example.Constants.VALUE or com.example.Constants.* + // The last segment is a member name if it starts with lowercase, is ALL_CAPS, or is a wildcard + const segments = importPath.split('.'); + if (segments.length < 3) return null; + + const lastSeg = segments[segments.length - 1]; + if (lastSeg === '*' || /^[a-z]/.test(lastSeg) || /^[A-Z_]+$/.test(lastSeg)) { + const classPath = segments.slice(0, -1).join('/'); + + for (const ext of extensions) { + const classSuffix = classPath + ext; + if (index) { + const result = index.get(classSuffix) || index.getInsensitive(classSuffix); + if (result) return result; + } else { + const fullSuffix = '/' + classSuffix; + for (let i = 0; i < normalizedFileList.length; i++) { + if (normalizedFileList[i].endsWith(fullSuffix) || + normalizedFileList[i].toLowerCase().endsWith(fullSuffix.toLowerCase())) { + return allFileList[i]; + } + } + } + } + } + + return null; +} diff --git a/gitnexus/src/core/ingestion/resolvers/php.ts b/gitnexus/src/core/ingestion/resolvers/php.ts new file mode 100644 index 0000000000..c05ef4e6d3 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/php.ts @@ -0,0 +1,51 @@ +/** + * PHP PSR-4 import resolution. + * Handles use-statement resolution via composer.json autoload mappings. + */ + +import type { SuffixIndex } from './utils.js'; +import { suffixResolve } from './utils.js'; + +/** PHP Composer PSR-4 autoload config */ +export interface ComposerConfig { + /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */ + psr4: Map<string, string>; +} + +/** + * Resolve a PHP use-statement import path using PSR-4 mappings. + * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php" + */ +export function resolvePhpImport( + importPath: string, + composerConfig: ComposerConfig | null, + allFiles: Set<string>, + normalizedFileList: string[], + allFileList: string[], + index?: SuffixIndex, +): string | null { + // Normalize: replace backslashes with forward slashes + const normalized = importPath.replace(/\\/g, '/'); + + // Try PSR-4 resolution if composer.json was found + if (composerConfig) { + // Sort namespaces by length descending (longest match wins) + const sorted = [...composerConfig.psr4.entries()].sort((a, b) => b[0].length - a[0].length); + for (const [nsPrefix, dirPrefix] of sorted) { + const nsPrefixSlash = nsPrefix.replace(/\\/g, '/'); + if (normalized.startsWith(nsPrefixSlash + '/') || normalized === nsPrefixSlash) { + const remainder = normalized.slice(nsPrefixSlash.length).replace(/^\//, ''); + const filePath = dirPrefix + (remainder ? '/' + remainder : '') + '.php'; + if (allFiles.has(filePath)) return filePath; + if (index) { + const result = index.getInsensitive(filePath); + if (result) return result; + } + } + } + } + + // Fallback: suffix matching (works without composer.json) + const pathParts = normalized.split('/').filter(Boolean); + return suffixResolve(pathParts, normalizedFileList, allFileList, index); +} diff --git a/gitnexus/src/core/ingestion/resolvers/python.ts b/gitnexus/src/core/ingestion/resolvers/python.ts new file mode 100644 index 0000000000..0e92b3e6d4 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/python.ts @@ -0,0 +1,59 @@ +/** + * Python import resolution — PEP 328 relative imports and proximity-based bare imports. + * Import system spec: PEP 302 (original), PEP 451 (current). + */ + +import { tryResolveWithExtensions } from './utils.js'; + +/** + * Resolve a Python import to a file path. + * + * 1. Relative (PEP 328): `.module`, `..module` — 1 dot = current package, each extra dot goes up one level. + * 2. Proximity bare import: static heuristic — checks the importer's own directory first. + * Approximates the common case where co-located files find each other without an installed package. + * Single-segment only — multi-segment (e.g. `os.path`) falls through to suffixResolve. + * Checks package (__init__.py) before module (.py), matching CPython's finder order (PEP 451 §4). + * Coexistence of both is physically impossible (same name = file vs directory), so the order + * only matters for spec compliance. + * Note: namespace packages (PEP 420, directory without __init__.py) are not handled. + * + * Returns null to let the caller fall through to suffixResolve. + */ +export function resolvePythonImport( + currentFile: string, + importPath: string, + allFiles: Set<string>, +): string | null { + // Relative import — PEP 328 (https://peps.python.org/pep-0328/) + if (importPath.startsWith('.')) { + const dotMatch = importPath.match(/^(\.+)(.*)/); + if (!dotMatch) return null; + + const dotCount = dotMatch[1].length; + const modulePart = dotMatch[2]; + const dirParts = currentFile.split('/').slice(0, -1); + + // PEP 328: more dots than directory levels → beyond top-level package → invalid + if (dotCount - 1 > dirParts.length) return null; + for (let i = 1; i < dotCount; i++) dirParts.pop(); + + if (modulePart) { + dirParts.push(...modulePart.replace(/\./g, '/').split('/')); + } + + return tryResolveWithExtensions(dirParts.join('/'), allFiles); + } + + // Proximity bare import — single-segment only; package before module (PEP 451 §4) + const pathLike = importPath.replace(/\./g, '/'); + if (pathLike.includes('/')) return null; + + // Normalize for Windows backslashes + const importerDir = currentFile.replace(/\\/g, '/').split('/').slice(0, -1).join('/'); + if (!importerDir) return null; + + if (allFiles.has(`${importerDir}/${pathLike}/__init__.py`)) return `${importerDir}/${pathLike}/__init__.py`; + if (allFiles.has(`${importerDir}/${pathLike}.py`)) return `${importerDir}/${pathLike}.py`; + + return null; +} diff --git a/gitnexus/src/core/ingestion/resolvers/ruby.ts b/gitnexus/src/core/ingestion/resolvers/ruby.ts new file mode 100644 index 0000000000..e0ae8e690c --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/ruby.ts @@ -0,0 +1,23 @@ +/** + * Ruby require/require_relative import resolution. + * Handles path resolution for Ruby's require and require_relative calls. + */ + +import type { SuffixIndex } from './utils.js'; +import { suffixResolve } from './utils.js'; + +/** + * Resolve a Ruby require/require_relative path to a matching .rb file. + * + * require_relative paths are pre-normalized to './' prefix by the caller. + * require paths use suffix matching (gem-style paths like 'json', 'net/http'). + */ +export function resolveRubyImport( + importPath: string, + normalizedFileList: string[], + allFileList: string[], + index?: SuffixIndex, +): string | null { + const pathParts = importPath.replace(/^\.\//, '').split('/').filter(Boolean); + return suffixResolve(pathParts, normalizedFileList, allFileList, index); +} diff --git a/gitnexus/src/core/ingestion/resolvers/rust.ts b/gitnexus/src/core/ingestion/resolvers/rust.ts new file mode 100644 index 0000000000..cc62c633f3 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/rust.ts @@ -0,0 +1,82 @@ +/** + * Rust module import resolution. + * Handles crate::, super::, self:: prefix paths and :: separators. + */ + +/** + * Resolve Rust use-path to a file. + * Handles crate::, super::, self:: prefixes and :: path separators. + */ +export function resolveRustImport( + currentFile: string, + importPath: string, + allFiles: Set<string>, +): string | null { + let rustPath: string; + + if (importPath.startsWith('crate::')) { + // crate:: resolves from src/ directory (standard Rust layout) + rustPath = importPath.slice(7).replace(/::/g, '/'); + + // Try from src/ (standard layout) + const fromSrc = tryRustModulePath('src/' + rustPath, allFiles); + if (fromSrc) return fromSrc; + + // Try from repo root (non-standard) + const fromRoot = tryRustModulePath(rustPath, allFiles); + if (fromRoot) return fromRoot; + + return null; + } + + if (importPath.startsWith('super::')) { + // super:: = parent directory of current file's module + const currentDir = currentFile.split('/').slice(0, -1); + currentDir.pop(); // Go up one level for super:: + rustPath = importPath.slice(7).replace(/::/g, '/'); + const fullPath = [...currentDir, rustPath].join('/'); + return tryRustModulePath(fullPath, allFiles); + } + + if (importPath.startsWith('self::')) { + // self:: = current module's directory + const currentDir = currentFile.split('/').slice(0, -1); + rustPath = importPath.slice(6).replace(/::/g, '/'); + const fullPath = [...currentDir, rustPath].join('/'); + return tryRustModulePath(fullPath, allFiles); + } + + // Bare path without prefix (e.g., from a use in a nested module) + // Convert :: to / and try suffix matching + if (importPath.includes('::')) { + rustPath = importPath.replace(/::/g, '/'); + return tryRustModulePath(rustPath, allFiles); + } + + return null; +} + +/** + * Try to resolve a Rust module path to a file. + * Tries: path.rs, path/mod.rs, and with the last segment stripped + * (last segment might be a symbol name, not a module). + */ +export function tryRustModulePath(modulePath: string, allFiles: Set<string>): string | null { + // Try direct: path.rs + if (allFiles.has(modulePath + '.rs')) return modulePath + '.rs'; + // Try directory: path/mod.rs + if (allFiles.has(modulePath + '/mod.rs')) return modulePath + '/mod.rs'; + // Try path/lib.rs (for crate root) + if (allFiles.has(modulePath + '/lib.rs')) return modulePath + '/lib.rs'; + + // The last segment might be a symbol (function, struct, etc.), not a module. + // Strip it and try again. + const lastSlash = modulePath.lastIndexOf('/'); + if (lastSlash > 0) { + const parentPath = modulePath.substring(0, lastSlash); + if (allFiles.has(parentPath + '.rs')) return parentPath + '.rs'; + if (allFiles.has(parentPath + '/mod.rs')) return parentPath + '/mod.rs'; + } + + return null; +} diff --git a/gitnexus/src/core/ingestion/resolvers/standard.ts b/gitnexus/src/core/ingestion/resolvers/standard.ts new file mode 100644 index 0000000000..c6809e49d9 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/standard.ts @@ -0,0 +1,151 @@ +/** + * Standard import path resolution. + * Handles relative imports, path alias rewriting, and generic suffix matching. + * Used as the fallback when language-specific resolvers don't match. + */ + +import type { SuffixIndex } from './utils.js'; +import { tryResolveWithExtensions, suffixResolve } from './utils.js'; +import { resolveRustImport } from './rust.js'; +import { SupportedLanguages } from '../../../config/supported-languages.js'; + +/** TypeScript path alias config parsed from tsconfig.json */ +export interface TsconfigPaths { + /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */ + aliases: Map<string, string>; + /** Base URL for path resolution (relative to repo root) */ + baseUrl: string; +} + +/** Max entries in the resolve cache. Beyond this, entries are evicted. + * 100K entries ≈ 15MB — covers the most common import patterns. */ +export const RESOLVE_CACHE_CAP = 100_000; + +/** + * Resolve an import path to a file path in the repository. + * + * Language-specific preprocessing is applied before the generic resolution: + * - TypeScript/JavaScript: rewrites tsconfig path aliases + * - Rust: converts crate::/super::/self:: to relative paths + * + * Java wildcards and Go package imports are handled separately in processImports + * because they resolve to multiple files. + */ +export const resolveImportPath = ( + currentFile: string, + importPath: string, + allFiles: Set<string>, + allFileList: string[], + normalizedFileList: string[], + resolveCache: Map<string, string | null>, + language: SupportedLanguages, + tsconfigPaths: TsconfigPaths | null, + index?: SuffixIndex, +): string | null => { + const cacheKey = `${currentFile}::${importPath}`; + if (resolveCache.has(cacheKey)) return resolveCache.get(cacheKey) ?? null; + + const cache = (result: string | null): string | null => { + // Evict oldest 20% when cap is reached instead of clearing all + if (resolveCache.size >= RESOLVE_CACHE_CAP) { + const evictCount = Math.floor(RESOLVE_CACHE_CAP * 0.2); + const iter = resolveCache.keys(); + for (let i = 0; i < evictCount; i++) { + const key = iter.next().value; + if (key !== undefined) resolveCache.delete(key); + } + } + resolveCache.set(cacheKey, result); + return result; + }; + + // ---- TypeScript/JavaScript: rewrite path aliases ---- + if ( + (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) && + tsconfigPaths && + !importPath.startsWith('.') + ) { + for (const [aliasPrefix, targetPrefix] of tsconfigPaths.aliases) { + if (importPath.startsWith(aliasPrefix)) { + const remainder = importPath.slice(aliasPrefix.length); + // Build the rewritten path relative to baseUrl + const rewritten = tsconfigPaths.baseUrl === '.' + ? targetPrefix + remainder + : tsconfigPaths.baseUrl + '/' + targetPrefix + remainder; + + // Try direct resolution from repo root + const resolved = tryResolveWithExtensions(rewritten, allFiles); + if (resolved) return cache(resolved); + + // Try suffix matching as fallback + const parts = rewritten.split('/').filter(Boolean); + const suffixResult = suffixResolve(parts, normalizedFileList, allFileList, index); + if (suffixResult) return cache(suffixResult); + } + } + } + + // ---- Rust: convert module path syntax to file paths ---- + if (language === SupportedLanguages.Rust) { + // Handle grouped imports: use crate::module::{Foo, Bar, Baz} + // Extract the prefix path before ::{...} and resolve the module, not the symbols + let rustImportPath = importPath; + const braceIdx = importPath.indexOf('::{'); + if (braceIdx !== -1) { + rustImportPath = importPath.substring(0, braceIdx); + } else if (importPath.startsWith('{') && importPath.endsWith('}')) { + // Top-level grouped imports: use {crate::a, crate::b} + // Iterate each part and return the first that resolves. This function returns a single + // string, so callers that need ALL edges must intercept before reaching here (see the + // Rust grouped-import blocks in processImports / processImportsBatch). This fallback + // handles any path that reaches resolveImportPath directly. + const inner = importPath.slice(1, -1); + const parts = inner.split(',').map(p => p.trim()).filter(Boolean); + for (const part of parts) { + const partResult = resolveRustImport(currentFile, part, allFiles); + if (partResult) return cache(partResult); + } + return cache(null); + } + + const rustResult = resolveRustImport(currentFile, rustImportPath, allFiles); + if (rustResult) return cache(rustResult); + // Fall through to generic resolution if Rust-specific didn't match + } + + // ---- Generic relative import resolution (./ and ../) ---- + const currentDir = currentFile.split('/').slice(0, -1); + const parts = importPath.split('/'); + + for (const part of parts) { + if (part === '.') continue; + if (part === '..') { + currentDir.pop(); + } else { + currentDir.push(part); + } + } + + const basePath = currentDir.join('/'); + + if (importPath.startsWith('.')) { + const resolved = tryResolveWithExtensions(basePath, allFiles); + return cache(resolved); + } + + // ---- Generic package/absolute import resolution (suffix matching) ---- + // Java wildcards are handled in processImports, not here + if (importPath.endsWith('.*')) { + return cache(null); + } + + // C/C++ includes use actual file paths (e.g. "animal.h") — don't convert dots to slashes + const isCpp = language === SupportedLanguages.C || language === SupportedLanguages.CPlusPlus; + const pathLike = importPath.includes('/') || isCpp + ? importPath + : importPath.replace(/\./g, '/'); + const pathParts = pathLike.split('/').filter(Boolean); + + const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index); + return cache(resolved); +}; diff --git a/gitnexus/src/core/ingestion/resolvers/utils.ts b/gitnexus/src/core/ingestion/resolvers/utils.ts new file mode 100644 index 0000000000..3c7a1eb2e4 --- /dev/null +++ b/gitnexus/src/core/ingestion/resolvers/utils.ts @@ -0,0 +1,158 @@ +/** + * Shared utilities for import resolution. + * Extracted from import-processor.ts to reduce file size. + */ + +/** All file extensions to try during resolution */ +export const EXTENSIONS = [ + '', + // TypeScript/JavaScript + '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js', + // Python + '.py', '/__init__.py', + // Java + '.java', + // Kotlin + '.kt', '.kts', + // C/C++ + '.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.hh', + // C# + '.cs', + // Go + '.go', + // Rust + '.rs', '/mod.rs', + // PHP + '.php', '.phtml', + // Swift + '.swift', + // Ruby + '.rb', +]; + +/** + * Try to match a path (with extensions) against the known file set. + * Returns the matched file path or null. + */ +export function tryResolveWithExtensions( + basePath: string, + allFiles: Set<string>, +): string | null { + for (const ext of EXTENSIONS) { + const candidate = basePath + ext; + if (allFiles.has(candidate)) return candidate; + } + return null; +} + +/** + * Build a suffix index for O(1) endsWith lookups. + * Maps every possible path suffix to its original file path. + * e.g. for "src/com/example/Foo.java": + * "Foo.java" -> "src/com/example/Foo.java" + * "example/Foo.java" -> "src/com/example/Foo.java" + * "com/example/Foo.java" -> "src/com/example/Foo.java" + * etc. + */ +export interface SuffixIndex { + /** Exact suffix lookup (case-sensitive) */ + get(suffix: string): string | undefined; + /** Case-insensitive suffix lookup */ + getInsensitive(suffix: string): string | undefined; + /** Get all files in a directory suffix */ + getFilesInDir(dirSuffix: string, extension: string): string[]; +} + +export function buildSuffixIndex(normalizedFileList: string[], allFileList: string[]): SuffixIndex { + // Map: normalized suffix -> original file path + const exactMap = new Map<string, string>(); + // Map: lowercase suffix -> original file path + const lowerMap = new Map<string, string>(); + // Map: directory suffix -> list of file paths in that directory + const dirMap = new Map<string, string[]>(); + + for (let i = 0; i < normalizedFileList.length; i++) { + const normalized = normalizedFileList[i]; + const original = allFileList[i]; + const parts = normalized.split('/'); + + // Index all suffixes: "a/b/c.java" -> ["c.java", "b/c.java", "a/b/c.java"] + for (let j = parts.length - 1; j >= 0; j--) { + const suffix = parts.slice(j).join('/'); + // Only store first match (longest path wins for ambiguous suffixes) + if (!exactMap.has(suffix)) { + exactMap.set(suffix, original); + } + const lower = suffix.toLowerCase(); + if (!lowerMap.has(lower)) { + lowerMap.set(lower, original); + } + } + + // Index directory membership + const lastSlash = normalized.lastIndexOf('/'); + if (lastSlash >= 0) { + // Build all directory suffixes + const dirParts = parts.slice(0, -1); + const fileName = parts[parts.length - 1]; + const ext = fileName.substring(fileName.lastIndexOf('.')); + + for (let j = dirParts.length - 1; j >= 0; j--) { + const dirSuffix = dirParts.slice(j).join('/'); + const key = `${dirSuffix}:${ext}`; + let list = dirMap.get(key); + if (!list) { + list = []; + dirMap.set(key, list); + } + list.push(original); + } + } + } + + return { + get: (suffix: string) => exactMap.get(suffix), + getInsensitive: (suffix: string) => lowerMap.get(suffix.toLowerCase()), + getFilesInDir: (dirSuffix: string, extension: string) => { + return dirMap.get(`${dirSuffix}:${extension}`) || []; + }, + }; +} + +/** + * Suffix-based resolution using index. O(1) per lookup instead of O(files). + */ +export function suffixResolve( + pathParts: string[], + normalizedFileList: string[], + allFileList: string[], + index?: SuffixIndex, +): string | null { + if (index) { + for (let i = 0; i < pathParts.length; i++) { + const suffix = pathParts.slice(i).join('/'); + for (const ext of EXTENSIONS) { + const suffixWithExt = suffix + ext; + const result = index.get(suffixWithExt) || index.getInsensitive(suffixWithExt); + if (result) return result; + } + } + return null; + } + + // Fallback: linear scan (for backward compatibility) + for (let i = 0; i < pathParts.length; i++) { + const suffix = pathParts.slice(i).join('/'); + for (const ext of EXTENSIONS) { + const suffixWithExt = suffix + ext; + const suffixPattern = '/' + suffixWithExt; + const matchIdx = normalizedFileList.findIndex(filePath => + filePath.endsWith(suffixPattern) || filePath.toLowerCase().endsWith(suffixPattern.toLowerCase()) + ); + if (matchIdx !== -1) { + return allFileList[matchIdx]; + } + } + } + return null; +} diff --git a/gitnexus/src/core/ingestion/symbol-table.ts b/gitnexus/src/core/ingestion/symbol-table.ts index c8c35d56f9..5d3fbef7c7 100644 --- a/gitnexus/src/core/ingestion/symbol-table.ts +++ b/gitnexus/src/core/ingestion/symbol-table.ts @@ -1,14 +1,29 @@ +import type { NodeLabel } from '../graph/types.js'; + export interface SymbolDefinition { nodeId: string; filePath: string; - type: string; // 'Function', 'Class', etc. + type: NodeLabel; + parameterCount?: number; + /** Raw return type text extracted from AST (e.g. 'User', 'Promise<User>') */ + returnType?: string; + /** Declared type for non-callable symbols — fields/properties (e.g. 'Address', 'List<User>') */ + declaredType?: string; + /** Links Method/Constructor/Property to owning Class/Struct/Trait nodeId */ + ownerId?: string; } export interface SymbolTable { /** * Register a new symbol definition */ - add: (filePath: string, name: string, nodeId: string, type: string) => void; + add: ( + filePath: string, + name: string, + nodeId: string, + type: NodeLabel, + metadata?: { parameterCount?: number; returnType?: string; declaredType?: string; ownerId?: string } + ) => void; /** * High Confidence: Look for a symbol specifically inside a file @@ -16,12 +31,32 @@ export interface SymbolTable { */ lookupExact: (filePath: string, name: string) => string | undefined; + /** + * High Confidence: Look for a symbol in a specific file, returning full definition. + * Includes type information needed for heritage resolution (Class vs Interface). + */ + lookupExactFull: (filePath: string, name: string) => SymbolDefinition | undefined; + /** * Low Confidence: Look for a symbol anywhere in the project * Used when imports are missing or for framework magic */ lookupFuzzy: (name: string) => SymbolDefinition[]; - + + /** + * Low Confidence: Look for callable symbols (Function/Method/Constructor) by name. + * Faster than `lookupFuzzy` + filter — backed by a lazy callable-only index. + * Used by ReturnTypeLookup to resolve callee → return type. + */ + lookupFuzzyCallable: (name: string) => SymbolDefinition[]; + + /** + * Look up a field/property by its owning class nodeId and field name. + * O(1) via dedicated eagerly-populated index keyed by `ownerNodeId\0fieldName`. + * Returns undefined when no matching property exists or the owner is ambiguous. + */ + lookupFieldByOwner: (ownerNodeId: string, fieldName: string) => SymbolDefinition | undefined; + /** * Debugging: See how many symbols are tracked */ @@ -34,38 +69,98 @@ export interface SymbolTable { } export const createSymbolTable = (): SymbolTable => { - // 1. File-Specific Index (The "Good" one) - // Structure: FilePath -> (SymbolName -> NodeID) - const fileIndex = new Map<string, Map<string, string>>(); + // 1. File-Specific Index — stores full SymbolDefinition for O(1) lookupExactFull + // Structure: FilePath -> (SymbolName -> SymbolDefinition) + const fileIndex = new Map<string, Map<string, SymbolDefinition>>(); // 2. Global Reverse Index (The "Backup") // Structure: SymbolName -> [List of Definitions] const globalIndex = new Map<string, SymbolDefinition[]>(); - const add = (filePath: string, name: string, nodeId: string, type: string) => { - // A. Add to File Index + // 3. Lazy Callable Index — populated on first lookupFuzzyCallable call. + // Structure: SymbolName -> [Callable Definitions] + // Only Function, Method, Constructor symbols are indexed. + let callableIndex: Map<string, SymbolDefinition[]> | null = null; + + // 4. Eagerly-populated Field/Property Index — keyed by "ownerNodeId\0fieldName". + // Only Property symbols with ownerId and declaredType are indexed. + const fieldByOwner = new Map<string, SymbolDefinition>(); + + const CALLABLE_TYPES = new Set(['Function', 'Method', 'Constructor']); + + const add = ( + filePath: string, + name: string, + nodeId: string, + type: NodeLabel, + metadata?: { parameterCount?: number; returnType?: string; declaredType?: string; ownerId?: string } + ) => { + const def: SymbolDefinition = { + nodeId, + filePath, + type, + ...(metadata?.parameterCount !== undefined ? { parameterCount: metadata.parameterCount } : {}), + ...(metadata?.returnType !== undefined ? { returnType: metadata.returnType } : {}), + ...(metadata?.declaredType !== undefined ? { declaredType: metadata.declaredType } : {}), + ...(metadata?.ownerId !== undefined ? { ownerId: metadata.ownerId } : {}), + }; + + // A. Add to File Index (shared reference — zero additional memory) if (!fileIndex.has(filePath)) { fileIndex.set(filePath, new Map()); } - fileIndex.get(filePath)!.set(name, nodeId); + fileIndex.get(filePath)!.set(name, def); - // B. Add to Global Index + // B. Properties go to fieldByOwner index only — skip globalIndex to prevent + // namespace pollution for common names like 'id', 'name', 'type'. + // Index ALL properties (even without declaredType) so write-access tracking + // can resolve field ownership for dynamically-typed languages (Ruby, JS). + if (type === 'Property' && metadata?.ownerId) { + fieldByOwner.set(`${metadata.ownerId}\0${name}`, def); + // Still add to fileIndex above (for lookupExact), but skip globalIndex + return; + } + + // C. Add to Global Index (same object reference) if (!globalIndex.has(name)) { globalIndex.set(name, []); } - globalIndex.get(name)!.push({ nodeId, filePath, type }); + globalIndex.get(name)!.push(def); + + // D. Invalidate the lazy callable index only when adding callable types + if (CALLABLE_TYPES.has(type)) { + callableIndex = null; + } }; const lookupExact = (filePath: string, name: string): string | undefined => { - const fileSymbols = fileIndex.get(filePath); - if (!fileSymbols) return undefined; - return fileSymbols.get(name); + return fileIndex.get(filePath)?.get(name)?.nodeId; + }; + + const lookupExactFull = (filePath: string, name: string): SymbolDefinition | undefined => { + return fileIndex.get(filePath)?.get(name); }; const lookupFuzzy = (name: string): SymbolDefinition[] => { return globalIndex.get(name) || []; }; + const lookupFuzzyCallable = (name: string): SymbolDefinition[] => { + if (!callableIndex) { + // Build the callable index lazily on first use + callableIndex = new Map(); + for (const [symName, defs] of globalIndex) { + const callables = defs.filter(d => CALLABLE_TYPES.has(d.type)); + if (callables.length > 0) callableIndex.set(symName, callables); + } + } + return callableIndex.get(name) ?? []; + }; + + const lookupFieldByOwner = (ownerNodeId: string, fieldName: string): SymbolDefinition | undefined => { + return fieldByOwner.get(`${ownerNodeId}\0${fieldName}`); + }; + const getStats = () => ({ fileCount: fileIndex.size, globalSymbolCount: globalIndex.size @@ -74,7 +169,9 @@ export const createSymbolTable = (): SymbolTable => { const clear = () => { fileIndex.clear(); globalIndex.clear(); + callableIndex = null; + fieldByOwner.clear(); }; - return { add, lookupExact, lookupFuzzy, getStats, clear }; -}; \ No newline at end of file + return { add, lookupExact, lookupExactFull, lookupFuzzy, lookupFuzzyCallable, lookupFieldByOwner, getStats, clear }; +}; diff --git a/gitnexus/src/core/ingestion/tree-sitter-queries.ts b/gitnexus/src/core/ingestion/tree-sitter-queries.ts index f8bcd7addb..31945bef43 100644 --- a/gitnexus/src/core/ingestion/tree-sitter-queries.ts +++ b/gitnexus/src/core/ingestion/tree-sitter-queries.ts @@ -47,6 +47,10 @@ export const TYPESCRIPT_QUERIES = ` (import_statement source: (string) @import.source) @import +; Re-export statements: export { X } from './y' +(export_statement + source: (string) @import.source) @import + (call_expression function: (identifier) @call.name) @call @@ -54,6 +58,23 @@ export const TYPESCRIPT_QUERIES = ` function: (member_expression property: (property_identifier) @call.name)) @call +; Constructor calls: new Foo() +(new_expression + constructor: (identifier) @call.name) @call + +; Class properties — public_field_definition covers most TS class fields +(public_field_definition + name: (property_identifier) @name) @definition.property + +; Private class fields: #address: Address +(public_field_definition + name: (private_property_identifier) @name) @definition.property + +; Constructor parameter properties: constructor(public address: Address) +(required_parameter + (accessibility_modifier) + pattern: (identifier) @name) @definition.property + ; Heritage queries - class extends (class_declaration name: (type_identifier) @heritage.class @@ -67,9 +88,23 @@ export const TYPESCRIPT_QUERIES = ` (class_heritage (implements_clause (type_identifier) @heritage.implements))) @heritage.impl + +; Write access: obj.field = value +(assignment_expression + left: (member_expression + object: (_) @assignment.receiver + property: (property_identifier) @assignment.property) + right: (_)) @assignment + +; Write access: obj.field += value (compound assignment) +(augmented_assignment_expression + left: (member_expression + object: (_) @assignment.receiver + property: (property_identifier) @assignment.property) + right: (_)) @assignment `; -// JavaScript queries - works with tree-sitter-javascript +// JavaScript queries - works with tree-sitter-javascript export const JAVASCRIPT_QUERIES = ` (class_declaration name: (identifier) @name) @definition.class @@ -105,6 +140,10 @@ export const JAVASCRIPT_QUERIES = ` (import_statement source: (string) @import.source) @import +; Re-export statements: export { X } from './y' +(export_statement + source: (string) @import.source) @import + (call_expression function: (identifier) @call.name) @call @@ -112,12 +151,34 @@ export const JAVASCRIPT_QUERIES = ` function: (member_expression property: (property_identifier) @call.name)) @call +; Constructor calls: new Foo() +(new_expression + constructor: (identifier) @call.name) @call + +; Class fields — field_definition captures JS class fields (class User { address = ... }) +(field_definition + property: (property_identifier) @name) @definition.property + ; Heritage queries - class extends (JavaScript uses different AST than TypeScript) ; In tree-sitter-javascript, class_heritage directly contains the parent identifier (class_declaration name: (identifier) @heritage.class (class_heritage (identifier) @heritage.extends)) @heritage + +; Write access: obj.field = value +(assignment_expression + left: (member_expression + object: (_) @assignment.receiver + property: (property_identifier) @assignment.property) + right: (_)) @assignment + +; Write access: obj.field += value (compound assignment) +(augmented_assignment_expression + left: (member_expression + object: (_) @assignment.receiver + property: (property_identifier) @assignment.property) + right: (_)) @assignment `; // Python queries - works with tree-sitter-python @@ -134,6 +195,9 @@ export const PYTHON_QUERIES = ` (import_from_statement module_name: (dotted_name) @import.source) @import +(import_from_statement + module_name: (relative_import) @import.source) @import + (call function: (identifier) @call.name) @call @@ -141,11 +205,33 @@ export const PYTHON_QUERIES = ` function: (attribute attribute: (identifier) @call.name)) @call +; Class attribute type annotations — PEP 526: address: Address or address: Address = Address() +; Both bare annotations (address: Address) and annotated assignments (name: str = "test") +; are parsed as (assignment left: ... type: ...) in tree-sitter-python. +(expression_statement + (assignment + left: (identifier) @name + type: (type)) @definition.property) + ; Heritage queries - Python class inheritance (class_definition name: (identifier) @heritage.class superclasses: (argument_list (identifier) @heritage.extends)) @heritage + +; Write access: obj.field = value +(assignment + left: (attribute + object: (_) @assignment.receiver + attribute: (identifier) @assignment.property) + right: (_)) @assignment + +; Write access: obj.field += value (compound assignment) +(augmented_assignment + left: (attribute + object: (_) @assignment.receiver + attribute: (identifier) @assignment.property) + right: (_)) @assignment `; // Java queries - works with tree-sitter-java @@ -160,6 +246,11 @@ export const JAVA_QUERIES = ` (method_declaration name: (identifier) @name) @definition.method (constructor_declaration name: (identifier) @name) @definition.constructor +; Fields — typed field declarations inside class bodies +(field_declaration + declarator: (variable_declarator + name: (identifier) @name)) @definition.property + ; Imports - capture any import declaration child as source (import_declaration (_) @import.source) @import @@ -167,6 +258,9 @@ export const JAVA_QUERIES = ` (method_invocation name: (identifier) @call.name) @call (method_invocation object: (_) name: (identifier) @call.name) @call +; Constructor calls: new Foo() +(object_creation_expression type: (type_identifier) @call.name) @call + ; Heritage - extends class (class_declaration name: (identifier) @heritage.class (superclass (type_identifier) @heritage.extends)) @heritage @@ -174,14 +268,28 @@ export const JAVA_QUERIES = ` ; Heritage - implements interfaces (class_declaration name: (identifier) @heritage.class (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl + +; Write access: obj.field = value +(assignment_expression + left: (field_access + object: (_) @assignment.receiver + field: (identifier) @assignment.property) + right: (_)) @assignment `; // C queries - works with tree-sitter-c export const C_QUERIES = ` -; Functions +; Functions (direct declarator) (function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function (declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function +; Functions returning pointers (pointer_declarator wraps function_declarator) +(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function +(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function + +; Functions returning double pointers (nested pointer_declarator) +(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function + ; Structs, Unions, Enums, Typedefs (struct_specifier name: (type_identifier) @name) @definition.struct (union_specifier name: (type_identifier) @name) @definition.union @@ -209,15 +317,39 @@ export const GO_QUERIES = ` ; Types (type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct (type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface -(type_declaration (type_spec name: (type_identifier) @name)) @definition.type ; Imports (import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import (import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import +; Struct fields — named field declarations inside struct types +(field_declaration_list + (field_declaration + name: (field_identifier) @name) @definition.property) + +; Struct embedding (anonymous fields = inheritance) +(type_declaration + (type_spec + name: (type_identifier) @heritage.class + type: (struct_type + (field_declaration_list + (field_declaration + type: (type_identifier) @heritage.extends))))) @definition.struct + ; Calls (call_expression function: (identifier) @call.name) @call (call_expression function: (selector_expression field: (field_identifier) @call.name)) @call + +; Struct literal construction: User{Name: "Alice"} +(composite_literal type: (type_identifier) @call.name) @call + +; Write access: obj.field = value +(assignment_statement + left: (expression_list + (selector_expression + operand: (_) @assignment.receiver + field: (field_identifier) @assignment.property)) + right: (_)) @assignment `; // C++ queries - works with tree-sitter-cpp @@ -228,10 +360,61 @@ export const CPP_QUERIES = ` (namespace_definition name: (namespace_identifier) @name) @definition.namespace (enum_specifier name: (type_identifier) @name) @definition.enum -; Functions & Methods +; Typedefs and unions (common in C-style headers and mixed C/C++ code) +(type_definition declarator: (type_identifier) @name) @definition.typedef +(union_specifier name: (type_identifier) @name) @definition.union + +; Macros +(preproc_function_def name: (identifier) @name) @definition.macro +(preproc_def name: (identifier) @name) @definition.macro + +; Functions & Methods (direct declarator) (function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function (function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method +; Functions/methods returning pointers (pointer_declarator wraps function_declarator) +(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function +(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method + +; Functions/methods returning double pointers (nested pointer_declarator) +(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function +(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))))) @definition.method + +; Functions/methods returning references (reference_declarator wraps function_declarator) +(function_definition declarator: (reference_declarator (function_declarator declarator: (identifier) @name))) @definition.function +(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method + +; Destructors (destructor_name is distinct from identifier in tree-sitter-cpp) +(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (destructor_name) @name))) @definition.method + +; Function declarations / prototypes (common in headers) +(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function +(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function + +; Class/struct data member fields (Address address; int count;) +; Uses field_identifier to exclude method declarations (which use function_declarator) +(field_declaration + declarator: (field_identifier) @name) @definition.property + +; Pointer member fields (Address* address;) +(field_declaration + declarator: (pointer_declarator + declarator: (field_identifier) @name)) @definition.property + +; Reference member fields (Address& address;) +(field_declaration + declarator: (reference_declarator + (field_identifier) @name)) @definition.property + +; Inline class method declarations (inside class body, no body: void Foo();) +(field_declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.method + +; Inline class method definitions (inside class body, with body: void Foo() { ... }) +(field_declaration_list + (function_definition + declarator: (function_declarator + declarator: [(field_identifier) (identifier) (operator_name) (destructor_name)] @name)) @definition.method) + ; Templates (template_declaration (class_specifier name: (type_identifier) @name)) @definition.template (template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template @@ -245,11 +428,22 @@ export const CPP_QUERIES = ` (call_expression function: (qualified_identifier name: (identifier) @call.name)) @call (call_expression function: (template_function name: (identifier) @call.name)) @call +; Constructor calls: new User() +(new_expression type: (type_identifier) @call.name) @call + ; Heritage (class_specifier name: (type_identifier) @heritage.class (base_class_clause (type_identifier) @heritage.extends)) @heritage (class_specifier name: (type_identifier) @heritage.class (base_class_clause (access_specifier) (type_identifier) @heritage.extends)) @heritage + +; Write access: obj.field = value +(assignment_expression + left: (field_expression + argument: (_) @assignment.receiver + field: (field_identifier) @assignment.property) + right: (_)) @assignment + `; // C# queries - works with tree-sitter-c-sharp @@ -262,9 +456,11 @@ export const CSHARP_QUERIES = ` (record_declaration name: (identifier) @name) @definition.record (delegate_declaration name: (identifier) @name) @definition.delegate -; Namespaces +; Namespaces (block form and C# 10+ file-scoped form) (namespace_declaration name: (identifier) @name) @definition.namespace (namespace_declaration name: (qualified_name) @name) @definition.namespace +(file_scoped_namespace_declaration name: (identifier) @name) @definition.namespace +(file_scoped_namespace_declaration name: (qualified_name) @name) @definition.namespace ; Methods & Properties (method_declaration name: (identifier) @name) @definition.method @@ -272,6 +468,10 @@ export const CSHARP_QUERIES = ` (constructor_declaration name: (identifier) @name) @definition.constructor (property_declaration name: (identifier) @name) @definition.property +; Primary constructors (C# 12): class User(string name, int age) { } +(class_declaration name: (identifier) @name (parameter_list) @definition.constructor) +(record_declaration name: (identifier) @name (parameter_list) @definition.constructor) + ; Using (using_directive (qualified_name) @import.source) @import (using_directive (identifier) @import.source) @import @@ -280,11 +480,31 @@ export const CSHARP_QUERIES = ` (invocation_expression function: (identifier) @call.name) @call (invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call +; Null-conditional method calls: user?.Save() +; Parses as: invocation_expression → conditional_access_expression → member_binding_expression → identifier +(invocation_expression + function: (conditional_access_expression + (member_binding_expression + (identifier) @call.name))) @call + +; Constructor calls: new Foo() and new Foo { Props } +(object_creation_expression type: (identifier) @call.name) @call + +; Target-typed new (C# 9): User u = new("x", 5) +(variable_declaration type: (identifier) @call.name (variable_declarator (implicit_object_creation_expression) @call)) + ; Heritage (class_declaration name: (identifier) @heritage.class - (base_list (simple_base_type (identifier) @heritage.extends))) @heritage + (base_list (identifier) @heritage.extends)) @heritage (class_declaration name: (identifier) @heritage.class - (base_list (simple_base_type (generic_name (identifier) @heritage.extends)))) @heritage + (base_list (generic_name (identifier) @heritage.extends))) @heritage + +; Write access: obj.field = value +(assignment_expression + left: (member_access_expression + expression: (_) @assignment.receiver + name: (identifier) @assignment.property) + right: (_)) @assignment `; // Rust queries - works with tree-sitter-rust @@ -294,7 +514,8 @@ export const RUST_QUERIES = ` (struct_item name: (type_identifier) @name) @definition.struct (enum_item name: (type_identifier) @name) @definition.enum (trait_item name: (type_identifier) @name) @definition.trait -(impl_item type: (type_identifier) @name) @definition.impl +(impl_item type: (type_identifier) @name !trait) @definition.impl +(impl_item type: (generic_type type: (type_identifier) @name) !trait) @definition.impl (mod_item name: (identifier) @name) @definition.module ; Type aliases, const, static, macros @@ -312,9 +533,357 @@ export const RUST_QUERIES = ` (call_expression function: (scoped_identifier name: (identifier) @call.name)) @call (call_expression function: (generic_function function: (identifier) @call.name)) @call -; Heritage (trait implementation) +; Struct literal construction: User { name: value } +(struct_expression name: (type_identifier) @call.name) @call + +; Struct fields — named field declarations inside struct bodies +(field_declaration_list + (field_declaration + name: (field_identifier) @name) @definition.property) + +; Heritage (trait implementation) — all combinations of concrete/generic trait × concrete/generic type (impl_item trait: (type_identifier) @heritage.trait type: (type_identifier) @heritage.class) @heritage (impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (type_identifier) @heritage.class) @heritage +(impl_item trait: (type_identifier) @heritage.trait type: (generic_type type: (type_identifier) @heritage.class)) @heritage +(impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (generic_type type: (type_identifier) @heritage.class)) @heritage + +; Write access: obj.field = value +(assignment_expression + left: (field_expression + value: (_) @assignment.receiver + field: (field_identifier) @assignment.property) + right: (_)) @assignment + +; Write access: obj.field += value (compound assignment) +(compound_assignment_expr + left: (field_expression + value: (_) @assignment.receiver + field: (field_identifier) @assignment.property) + right: (_)) @assignment +`; + +// PHP queries - works with tree-sitter-php (php_only grammar) +export const PHP_QUERIES = ` +; ── Namespace ──────────────────────────────────────────────────────────────── +(namespace_definition + name: (namespace_name) @name) @definition.namespace + +; ── Classes ────────────────────────────────────────────────────────────────── +(class_declaration + name: (name) @name) @definition.class + +; ── Interfaces ─────────────────────────────────────────────────────────────── +(interface_declaration + name: (name) @name) @definition.interface + +; ── Traits ─────────────────────────────────────────────────────────────────── +(trait_declaration + name: (name) @name) @definition.trait + +; ── Enums (PHP 8.1) ────────────────────────────────────────────────────────── +(enum_declaration + name: (name) @name) @definition.enum + +; ── Top-level functions ─────────────────────────────────────────────────────── +(function_definition + name: (name) @name) @definition.function + +; ── Methods (including constructors) ───────────────────────────────────────── +(method_declaration + name: (name) @name) @definition.method + +; ── Class properties (including Eloquent $fillable, $casts, etc.) ──────────── +(property_declaration + (property_element + (variable_name + (name) @name))) @definition.property + +; Constructor property promotion (PHP 8.0+: public Address $address in __construct) +(method_declaration + parameters: (formal_parameters + (property_promotion_parameter + name: (variable_name + (name) @name)))) @definition.property + +; ── Imports: use statements ────────────────────────────────────────────────── +; Simple: use App\\Models\\User; +(namespace_use_declaration + (namespace_use_clause + (qualified_name) @import.source)) @import + +; ── Function/method calls ──────────────────────────────────────────────────── +; Regular function call: foo() +(function_call_expression + function: (name) @call.name) @call + +; Method call: $obj->method() +(member_call_expression + name: (name) @call.name) @call + +; Nullsafe method call: $obj?->method() +(nullsafe_member_call_expression + name: (name) @call.name) @call + +; Static call: Foo::bar() (php_only uses scoped_call_expression) +(scoped_call_expression + name: (name) @call.name) @call + +; Constructor call: new User() +(object_creation_expression (name) @call.name) @call + +; ── Heritage: extends ──────────────────────────────────────────────────────── +(class_declaration + name: (name) @heritage.class + (base_clause + [(name) (qualified_name)] @heritage.extends)) @heritage + +; ── Heritage: implements ───────────────────────────────────────────────────── +(class_declaration + name: (name) @heritage.class + (class_interface_clause + [(name) (qualified_name)] @heritage.implements)) @heritage.impl + +; ── Heritage: use trait (must capture enclosing class name) ────────────────── +(class_declaration + name: (name) @heritage.class + body: (declaration_list + (use_declaration + [(name) (qualified_name)] @heritage.trait))) @heritage + +; Write access: $obj->field = value +(assignment_expression + left: (member_access_expression + object: (_) @assignment.receiver + name: (name) @assignment.property) + right: (_)) @assignment + +; Write access: ClassName::$field = value (static property) +(assignment_expression + left: (scoped_property_access_expression + scope: (_) @assignment.receiver + name: (variable_name (name) @assignment.property)) + right: (_)) @assignment +`; + +// Ruby queries - works with tree-sitter-ruby +// NOTE: Ruby uses `call` for require, include, extend, prepend, attr_* etc. +// These are all captured as @call and routed in JS post-processing: +// - require/require_relative → import extraction +// - include/extend/prepend → heritage (mixin) extraction +// - attr_accessor/attr_reader/attr_writer → property definition extraction +// - everything else → regular call extraction +export const RUBY_QUERIES = ` +; ── Modules ────────────────────────────────────────────────────────────────── +(module + name: (constant) @name) @definition.module + +; ── Classes ────────────────────────────────────────────────────────────────── +(class + name: (constant) @name) @definition.class + +; ── Instance methods ───────────────────────────────────────────────────────── +(method + name: (identifier) @name) @definition.method + +; ── Singleton (class-level) methods ────────────────────────────────────────── +(singleton_method + name: (identifier) @name) @definition.method + +; ── All calls (require, include, attr_*, and regular calls routed in JS) ───── +(call + method: (identifier) @call.name) @call + +; ── Bare calls without parens (identifiers at statement level are method calls) ─ +; NOTE: This may over-capture variable reads as calls (e.g. 'result' at +; statement level). Ruby's grammar makes bare identifiers ambiguous — they +; could be local variables or zero-arity method calls. Post-processing via +; isBuiltInOrNoise and symbol resolution filtering suppresses most false +; positives, but a variable name that coincidentally matches a method name +; elsewhere may produce a false CALLS edge. +(body_statement + (identifier) @call.name @call) + +; ── Heritage: class < SuperClass ───────────────────────────────────────────── +(class + name: (constant) @heritage.class + superclass: (superclass + (constant) @heritage.extends)) @heritage + +; Write access: obj.field = value (Ruby setter — syntactically a method call to field=) +(assignment + left: (call + receiver: (_) @assignment.receiver + method: (identifier) @assignment.property) + right: (_)) @assignment + +; Write access: obj.field += value (compound assignment — operator_assignment node, not assignment) +(operator_assignment + left: (call + receiver: (_) @assignment.receiver + method: (identifier) @assignment.property) + right: (_)) @assignment +`; + +// Kotlin queries - works with tree-sitter-kotlin (fwcd/tree-sitter-kotlin) +// Based on official tags.scm; functions use simple_identifier, classes use type_identifier +export const KOTLIN_QUERIES = ` +; ── Interfaces ───────────────────────────────────────────────────────────── +; tree-sitter-kotlin (fwcd) has no interface_declaration node type. +; Interfaces are class_declaration nodes with an anonymous "interface" keyword child. +(class_declaration + "interface" + (type_identifier) @name) @definition.interface + +; ── Classes (regular, data, sealed, enum) ──────────────────────────────── +; All have the anonymous "class" keyword child. enum class has both +; "enum" and "class" children — the "class" child still matches. +(class_declaration + "class" + (type_identifier) @name) @definition.class + +; ── Object declarations (Kotlin singletons) ────────────────────────────── +(object_declaration + (type_identifier) @name) @definition.class + +; ── Companion objects (named only) ─────────────────────────────────────── +(companion_object + (type_identifier) @name) @definition.class + +; ── Functions (top-level, member, extension) ────────────────────────────── +(function_declaration + (simple_identifier) @name) @definition.function + +; ── Properties ─────────────────────────────────────────────────────────── +(property_declaration + (variable_declaration + (simple_identifier) @name)) @definition.property + +; Primary constructor val/var parameters (data class, value class, regular class) +; binding_pattern_kind contains "val" or "var" — without it, the param is not a property +(class_parameter + (binding_pattern_kind) + (simple_identifier) @name) @definition.property + +; ── Enum entries ───────────────────────────────────────────────────────── +(enum_entry + (simple_identifier) @name) @definition.enum + +; ── Type aliases ───────────────────────────────────────────────────────── +(type_alias + (type_identifier) @name) @definition.type + +; ── Imports ────────────────────────────────────────────────────────────── +(import_header + (identifier) @import.source) @import + +; ── Function calls (direct) ────────────────────────────────────────────── +(call_expression + (simple_identifier) @call.name) @call + +; ── Method calls (via navigation: obj.method()) ────────────────────────── +(call_expression + (navigation_expression + (navigation_suffix + (simple_identifier) @call.name))) @call + +; ── Constructor invocations ────────────────────────────────────────────── +(constructor_invocation + (user_type + (type_identifier) @call.name)) @call + +; ── Infix function calls (e.g., a to b, x until y) ────────────────────── +(infix_expression + (simple_identifier) @call.name) @call + +; ── Heritage: extends / implements via delegation_specifier ────────────── +; Interface implementation (bare user_type): class Foo : Bar +(class_declaration + (type_identifier) @heritage.class + (delegation_specifier + (user_type (type_identifier) @heritage.extends))) @heritage + +; Class extension (constructor_invocation): class Foo : Bar() +(class_declaration + (type_identifier) @heritage.class + (delegation_specifier + (constructor_invocation + (user_type (type_identifier) @heritage.extends)))) @heritage + +; Write access: obj.field = value +(assignment + (directly_assignable_expression + (_) @assignment.receiver + (navigation_suffix + (simple_identifier) @assignment.property)) + (_)) @assignment + +`; + +// Swift queries - works with tree-sitter-swift +export const SWIFT_QUERIES = ` +; Classes +(class_declaration "class" name: (type_identifier) @name) @definition.class + +; Structs +(class_declaration "struct" name: (type_identifier) @name) @definition.struct + +; Enums +(class_declaration "enum" name: (type_identifier) @name) @definition.enum + +; Extensions (mapped to class — no dedicated label in schema) +(class_declaration "extension" name: (user_type (type_identifier) @name)) @definition.class + +; Actors +(class_declaration "actor" name: (type_identifier) @name) @definition.class + +; Protocols (mapped to interface) +(protocol_declaration name: (type_identifier) @name) @definition.interface + +; Type aliases +(typealias_declaration name: (type_identifier) @name) @definition.type + +; Functions (top-level and methods) +(function_declaration name: (simple_identifier) @name) @definition.function + +; Protocol method declarations +(protocol_function_declaration name: (simple_identifier) @name) @definition.method + +; Initializers +(init_declaration) @definition.constructor + +; Properties (stored and computed) +(property_declaration (pattern (simple_identifier) @name)) @definition.property + +; Imports +(import_declaration (identifier (simple_identifier) @import.source)) @import + +; Calls - direct function calls +(call_expression (simple_identifier) @call.name) @call + +; Calls - member/navigation calls (obj.method()) +(call_expression (navigation_expression (navigation_suffix (simple_identifier) @call.name))) @call + +; Heritage - class/struct/enum inheritance and protocol conformance +(class_declaration name: (type_identifier) @heritage.class + (inheritance_specifier inherits_from: (user_type (type_identifier) @heritage.extends))) @heritage + +; Heritage - protocol inheritance +(protocol_declaration name: (type_identifier) @heritage.class + (inheritance_specifier inherits_from: (user_type (type_identifier) @heritage.extends))) @heritage + +; Heritage - extension protocol conformance (e.g. extension Foo: SomeProtocol) +; Extensions wrap the name in user_type unlike class/struct/enum declarations +(class_declaration "extension" name: (user_type (type_identifier) @heritage.class) + (inheritance_specifier inherits_from: (user_type (type_identifier) @heritage.extends))) @heritage + +; Write access: obj.field = value +(assignment + (directly_assignable_expression + (_) @assignment.receiver + (navigation_suffix + (simple_identifier) @assignment.property)) + (_)) @assignment + `; export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = { @@ -326,6 +895,10 @@ export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = { [SupportedLanguages.Go]: GO_QUERIES, [SupportedLanguages.CPlusPlus]: CPP_QUERIES, [SupportedLanguages.CSharp]: CSHARP_QUERIES, + [SupportedLanguages.Ruby]: RUBY_QUERIES, [SupportedLanguages.Rust]: RUST_QUERIES, + [SupportedLanguages.PHP]: PHP_QUERIES, + [SupportedLanguages.Kotlin]: KOTLIN_QUERIES, + [SupportedLanguages.Swift]: SWIFT_QUERIES, }; \ No newline at end of file diff --git a/gitnexus/src/core/ingestion/type-env.ts b/gitnexus/src/core/ingestion/type-env.ts new file mode 100644 index 0000000000..0e4a2edaa4 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-env.ts @@ -0,0 +1,691 @@ +import type { SyntaxNode } from './utils.js'; +import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES, isBuiltInOrNoise } from './utils.js'; +import { SupportedLanguages } from '../../config/supported-languages.js'; +import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js'; +import type { ClassNameLookup, ReturnTypeLookup, ForLoopExtractorContext } from './type-extractors/types.js'; +import { extractSimpleTypeName, extractVarName, stripNullable, extractReturnTypeName } from './type-extractors/shared.js'; +import type { SymbolTable } from './symbol-table.js'; + +/** + * Per-file scoped type environment: maps (scope, variableName) → typeName. + * Scope-aware: variables inside functions are keyed by function name, + * file-level variables use the '' (empty string) scope. + * + * Design constraints: + * - Explicit-only: Tier 0 uses type annotations; Tier 1 infers from constructors + * - Tier 2: single-pass assignment chain propagation in source order — resolves + * `const b = a` when `a` already has a type from Tier 0/1 + * - Scope-aware: function-local variables don't collide across functions + * - Conservative: complex/generic types extract the base name only + * - Per-file: built once, used for receiver resolution, then discarded + */ +export type TypeEnv = Map<string, Map<string, string>>; + +/** File-level scope key */ +const FILE_SCOPE = ''; + +/** Fallback for languages where class names aren't in a 'name' field (e.g. Kotlin uses type_identifier). */ +const findTypeIdentifierChild = (node: SyntaxNode): SyntaxNode | null => { + for (let i = 0; i < node.childCount; i++) { + const child = node.child(i); + if (child && child.type === 'type_identifier') return child; + } + return null; +}; + +/** + * Per-file type environment with receiver resolution. + * Built once per file via `buildTypeEnv`, used for receiver-type filtering, + * then discarded. Encapsulates scope-aware type lookup and self/this/super + * AST resolution behind a single `.lookup()` method. + */ +export interface TypeEnvironment { + /** Look up a variable's resolved type, with self/this/super AST resolution. */ + lookup(varName: string, callNode: SyntaxNode): string | undefined; + /** Unverified cross-file constructor bindings for SymbolTable verification. */ + readonly constructorBindings: readonly ConstructorBinding[]; + /** Raw per-scope type bindings — for testing and debugging. */ + readonly env: TypeEnv; +} + +/** + * Position-indexed pattern binding: active only within a specific AST range. + * Used for smart-cast narrowing in mutually exclusive branches (e.g., Kotlin when arms). + */ +interface PatternOverride { + rangeStart: number; + rangeEnd: number; + typeName: string; +} + +/** scope → varName → overrides (checked in order, first range match wins) */ +type PatternOverrides = Map<string, Map<string, PatternOverride[]>>; + +/** AST node types that represent mutually exclusive branch containers for pattern bindings. */ +const PATTERN_BRANCH_TYPES = new Set([ + 'when_entry', // Kotlin when + 'switch_block_label', // Java switch (enhanced) +]); + +/** Walk up the AST from a pattern node to find the enclosing branch container. */ +const findPatternBranchScope = (node: SyntaxNode): SyntaxNode | undefined => { + let current = node.parent; + while (current) { + if (PATTERN_BRANCH_TYPES.has(current.type)) return current; + if (FUNCTION_NODE_TYPES.has(current.type)) return undefined; + current = current.parent; + } + return undefined; +}; + +/** Bare nullable keywords that fastStripNullable must reject. */ +const FAST_NULLABLE_KEYWORDS = new Set(['null', 'undefined', 'void', 'None', 'nil']); + +/** + * Fast-path nullable check: 90%+ of type names are simple identifiers (e.g. "User") + * that don't need the full stripNullable parse. Only call stripNullable when the + * string contains nullable markers ('|' for union types, '?' for nullable suffix). + */ +const fastStripNullable = (typeName: string): string | undefined => { + if (FAST_NULLABLE_KEYWORDS.has(typeName)) return undefined; + return (typeName.indexOf('|') === -1 && typeName.indexOf('?') === -1) + ? typeName + : stripNullable(typeName); +}; + +/** Implementation of the lookup logic — shared between TypeEnvironment and the legacy export. */ +const lookupInEnv = ( + env: TypeEnv, + varName: string, + callNode: SyntaxNode, + patternOverrides?: PatternOverrides, +): string | undefined => { + // Self/this receiver: resolve to enclosing class name via AST walk + if (varName === 'self' || varName === 'this' || varName === '$this') { + return findEnclosingClassName(callNode); + } + + // Super/base/parent receiver: resolve to the parent class name via AST walk. + // Walks up to the enclosing class, then extracts the superclass from its heritage node. + if (varName === 'super' || varName === 'base' || varName === 'parent') { + return findEnclosingParentClassName(callNode); + } + + // Determine the enclosing function scope for the call + const scopeKey = findEnclosingScopeKey(callNode); + + // Check position-indexed pattern overrides first (e.g., Kotlin when/is smart casts). + // These take priority over flat scopeEnv because they represent per-branch narrowing. + if (scopeKey && patternOverrides) { + const varOverrides = patternOverrides.get(scopeKey)?.get(varName); + if (varOverrides) { + const pos = callNode.startIndex; + for (const override of varOverrides) { + if (pos >= override.rangeStart && pos <= override.rangeEnd) { + return fastStripNullable(override.typeName); + } + } + } + } + + // Try function-local scope first + if (scopeKey) { + const scopeEnv = env.get(scopeKey); + if (scopeEnv) { + const result = scopeEnv.get(varName); + if (result) return fastStripNullable(result); + } + } + + // Fall back to file-level scope + const fileEnv = env.get(FILE_SCOPE); + const raw = fileEnv?.get(varName); + return raw ? fastStripNullable(raw) : undefined; +}; + + +/** + * Walk up the AST from a node to find the enclosing class/module name. + * Used to resolve `self`/`this` receivers to their containing type. + */ +const findEnclosingClassName = (node: SyntaxNode): string | undefined => { + let current = node.parent; + while (current) { + if (CLASS_CONTAINER_TYPES.has(current.type)) { + const nameNode = current.childForFieldName('name') + ?? findTypeIdentifierChild(current); + if (nameNode) return nameNode.text; + } + current = current.parent; + } + return undefined; +}; + +/** + * Walk up the AST to find the enclosing class, then extract its parent class name + * from the heritage/superclass AST node. Used to resolve `super`/`base`/`parent`. + * + * Supported patterns per tree-sitter grammar: + * - Java/Ruby: `superclass` field → type_identifier/constant + * - Python: `superclasses` field → argument_list → first identifier + * - TypeScript/JS: unnamed `class_heritage` child → `extends_clause` → identifier + * - C#: unnamed `base_list` child → first identifier + * - PHP: unnamed `base_clause` child → name + * - Kotlin: unnamed `delegation_specifier` child → constructor_invocation → user_type → type_identifier + * - C++: unnamed `base_class_clause` child → type_identifier + * - Swift: unnamed `inheritance_specifier` child → user_type → type_identifier + */ +const findEnclosingParentClassName = (node: SyntaxNode): string | undefined => { + let current = node.parent; + while (current) { + if (CLASS_CONTAINER_TYPES.has(current.type)) { + return extractParentClassFromNode(current); + } + current = current.parent; + } + return undefined; +}; + +/** Extract the parent/superclass name from a class declaration AST node. */ +const extractParentClassFromNode = (classNode: SyntaxNode): string | undefined => { + // 1. Named fields: Java (superclass), Ruby (superclass), Python (superclasses) + const superclassNode = classNode.childForFieldName('superclass'); + if (superclassNode) { + // Java: superclass > type_identifier or generic_type, Ruby: superclass > constant + const inner = superclassNode.childForFieldName('type') + ?? superclassNode.firstNamedChild + ?? superclassNode; + return extractSimpleTypeName(inner) ?? inner.text; + } + + const superclassesNode = classNode.childForFieldName('superclasses'); + if (superclassesNode) { + // Python: argument_list with identifiers or attribute nodes (e.g. models.Model) + const first = superclassesNode.firstNamedChild; + if (first) return extractSimpleTypeName(first) ?? first.text; + } + + // 2. Unnamed children: walk class node's children looking for heritage nodes + for (let i = 0; i < classNode.childCount; i++) { + const child = classNode.child(i); + if (!child) continue; + + switch (child.type) { + // TypeScript: class_heritage > extends_clause > type_identifier + // JavaScript: class_heritage > identifier (no extends_clause wrapper) + case 'class_heritage': { + for (let j = 0; j < child.childCount; j++) { + const clause = child.child(j); + if (clause?.type === 'extends_clause') { + const typeNode = clause.firstNamedChild; + if (typeNode) return extractSimpleTypeName(typeNode) ?? typeNode.text; + } + // JS: direct identifier child (no extends_clause wrapper) + if (clause?.type === 'identifier' || clause?.type === 'type_identifier') { + return clause.text; + } + } + break; + } + + // C#: base_list > identifier or generic_name > identifier + case 'base_list': { + const first = child.firstNamedChild; + if (first) { + // generic_name wraps the identifier: BaseClass<T> + if (first.type === 'generic_name') { + const inner = first.childForFieldName('name') ?? first.firstNamedChild; + if (inner) return inner.text; + } + return first.text; + } + break; + } + + // PHP: base_clause > name + case 'base_clause': { + const name = child.firstNamedChild; + if (name) return name.text; + break; + } + + // C++: base_class_clause > type_identifier (with optional access_specifier before it) + case 'base_class_clause': { + for (let j = 0; j < child.childCount; j++) { + const inner = child.child(j); + if (inner?.type === 'type_identifier') return inner.text; + } + break; + } + + // Kotlin: delegation_specifier > constructor_invocation > user_type > type_identifier + case 'delegation_specifier': { + const delegate = child.firstNamedChild; + if (delegate?.type === 'constructor_invocation') { + const userType = delegate.firstNamedChild; + if (userType?.type === 'user_type') { + const typeId = userType.firstNamedChild; + if (typeId) return typeId.text; + } + } + // Also handle plain user_type (interface conformance without parentheses) + if (delegate?.type === 'user_type') { + const typeId = delegate.firstNamedChild; + if (typeId) return typeId.text; + } + break; + } + + // Swift: inheritance_specifier > user_type > type_identifier + case 'inheritance_specifier': { + const userType = child.childForFieldName('inherits_from') ?? child.firstNamedChild; + if (userType?.type === 'user_type') { + const typeId = userType.firstNamedChild; + if (typeId) return typeId.text; + } + break; + } + } + } + + return undefined; +}; + +/** Find the enclosing function name for scope lookup. */ +const findEnclosingScopeKey = (node: SyntaxNode): string | undefined => { + let current = node.parent; + while (current) { + if (FUNCTION_NODE_TYPES.has(current.type)) { + const { funcName } = extractFunctionName(current); + if (funcName) return `${funcName}@${current.startIndex}`; + } + current = current.parent; + } + return undefined; +}; + +/** + * Create a lookup that checks both local AST class names AND the SymbolTable's + * global index. This allows extractInitializer functions to distinguish + * constructor calls from function calls (e.g. Kotlin `User()` vs `getUser()`) + * using cross-file type information when available. + * + * Only `.has()` is exposed — the SymbolTable doesn't support iteration. + * Results are memoized to avoid redundant lookupFuzzy scans across declarations. + */ +const createClassNameLookup = ( + localNames: Set<string>, + symbolTable?: SymbolTable, +): ClassNameLookup => { + if (!symbolTable) return localNames; + + const memo = new Map<string, boolean>(); + return { + has(name: string): boolean { + if (localNames.has(name)) return true; + const cached = memo.get(name); + if (cached !== undefined) return cached; + const result = symbolTable.lookupFuzzy(name).some(def => + def.type === 'Class' || def.type === 'Enum' || def.type === 'Struct', + ); + memo.set(name, result); + return result; + }, + }; +}; + +/** + * Build a TypeEnvironment from a tree-sitter AST for a given language. + * Single-pass: collects class/struct names, type bindings, AND constructor + * bindings that couldn't be resolved locally — all in one AST walk. + * + * When a symbolTable is provided (call-processor path), class names from across + * the project are available for constructor inference in languages like Kotlin + * where constructors are syntactically identical to function calls. + */ +/** + * Node types whose subtrees can NEVER contain type-relevant descendants + * (declarations, parameters, for-loops, class definitions, pattern bindings). + * Conservative leaf-only set — verified safe across all 12 supported language grammars. + * IMPORTANT: Do NOT add expression containers (arguments, binary_expression, etc.) — + * they can contain arrow functions with typed parameters. + */ +const SKIP_SUBTREE_TYPES = new Set([ + // Plain string literals (NOT template_string — it contains interpolated expressions + // that can hold arrow functions with typed parameters, e.g. `${(x: T) => x}`) + 'string', 'string_literal', + 'string_content', 'string_fragment', 'heredoc_body', + // Comments + 'comment', 'line_comment', 'block_comment', + // Numeric/boolean/null literals + 'number', 'integer_literal', 'float_literal', + 'true', 'false', 'null', + // Regex + 'regex', 'regex_pattern', +]); + +export const buildTypeEnv = ( + tree: { rootNode: SyntaxNode }, + language: SupportedLanguages, + symbolTable?: SymbolTable, +): TypeEnvironment => { + const env: TypeEnv = new Map(); + const patternOverrides: PatternOverrides = new Map(); + const localClassNames = new Set<string>(); + const classNames = createClassNameLookup(localClassNames, symbolTable); + const config = typeConfigs[language]; + const bindings: ConstructorBinding[] = []; + + // Build ReturnTypeLookup from optional SymbolTable. + // Conservative: returns undefined when callee is ambiguous (0 or 2+ matches). + const returnTypeLookup: ReturnTypeLookup = { + lookupReturnType(callee: string): string | undefined { + if (!symbolTable) return undefined; + if (isBuiltInOrNoise(callee)) return undefined; + const callables = symbolTable.lookupFuzzyCallable(callee); + if (callables.length !== 1) return undefined; + const rawReturn = callables[0].returnType; + if (!rawReturn) return undefined; + return extractReturnTypeName(rawReturn); + }, + lookupRawReturnType(callee: string): string | undefined { + if (!symbolTable) return undefined; + if (isBuiltInOrNoise(callee)) return undefined; + const callables = symbolTable.lookupFuzzyCallable(callee); + if (callables.length !== 1) return undefined; + return callables[0].returnType; + } + }; + + // Pre-compute combined set of node types that need extractTypeBinding. + // Single Set.has() replaces 3 separate checks per node in walk(). + const interestingNodeTypes = new Set<string>(); + TYPED_PARAMETER_TYPES.forEach(t => interestingNodeTypes.add(t)); + config.declarationNodeTypes.forEach(t => interestingNodeTypes.add(t)); + config.forLoopNodeTypes?.forEach(t => interestingNodeTypes.add(t)); + // Tier 2: copy-propagation (`const b = a`) and call-result propagation (`const b = foo()`) + const pendingCopies: Array<{ scope: string; lhs: string; rhs: string }> = []; + // NOTE: Infrastructure-ready — no language extractor currently returns { kind: 'callResult' } + // from extractPendingAssignment. When one does, this array will bind variables to their + // function return types at TypeEnv build time. See PendingAssignment in types.ts. + const pendingCallResults: Array<{ scope: string; lhs: string; callee: string }> = []; + // Maps `scope\0varName` → the type annotation AST node from the original declaration. + // Allows pattern extractors to navigate back to the declaration's generic type arguments + // (e.g., to extract T from Result<T, E> for `if let Ok(x) = res`). + // NOTE: This is a SUPERSET of scopeEnv — entries exist even when extractSimpleTypeName + // returns undefined for container types (User[], []User, List[User]). This is intentional: + // for-loop Strategy 1 needs the raw AST type node for exactly those container types. + const declarationTypeNodes = new Map<string, SyntaxNode>(); + + /** + * Try to extract a (variableName → typeName) binding from a single AST node. + * + * Resolution tiers (first match wins): + * - Tier 0: explicit type annotations via extractDeclaration / extractForLoopBinding + * - Tier 1: constructor-call inference via extractInitializer (fallback) + * + * Side effect: populates declarationTypeNodes for variables that have an explicit + * type annotation field on the declaration node. This allows pattern extractors to + * retrieve generic type arguments from the original declaration (e.g., extracting T + * from Result<T, E> for `if let Ok(x) = res`). + */ + const extractTypeBinding = (node: SyntaxNode, scopeEnv: Map<string, string>, scope: string): void => { + // This guard eliminates 90%+ of calls before any language dispatch. + if (TYPED_PARAMETER_TYPES.has(node.type)) { + // Capture the raw type annotation BEFORE extractParameter. + // Most languages use 'name' field; Rust uses 'pattern'; TS uses 'pattern' for some param types. + // Kotlin `parameter` nodes use positional children instead of named fields, + // so we fall back to scanning children by type when childForFieldName returns null. + let typeNode = node.childForFieldName('type'); + if (typeNode) { + const nameNode = node.childForFieldName('name') + ?? node.childForFieldName('pattern') + // Python typed_parameter: name is a positional child (identifier), not a named field + ?? (node.firstNamedChild?.type === 'identifier' ? node.firstNamedChild : null); + if (nameNode) { + const varName = extractVarName(nameNode); + if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) { + declarationTypeNodes.set(`${scope}\0${varName}`, typeNode); + } + } + } else { + // Fallback: positional children (Kotlin `parameter` → simple_identifier + user_type) + let fallbackName: SyntaxNode | null = null; + let fallbackType: SyntaxNode | null = null; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (!child) continue; + if (!fallbackName && (child.type === 'simple_identifier' || child.type === 'identifier')) { + fallbackName = child; + } + if (!fallbackType && (child.type === 'user_type' || child.type === 'type_identifier' + || child.type === 'generic_type' || child.type === 'parameterized_type')) { + fallbackType = child; + } + } + if (fallbackName && fallbackType) { + const varName = extractVarName(fallbackName); + if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) { + declarationTypeNodes.set(`${scope}\0${varName}`, fallbackType); + } + } + } + config.extractParameter(node, scopeEnv); + return; + } + // For-each loop variable bindings (Java/C#/Kotlin): explicit element types in the AST. + // Checked before declarationNodeTypes — loop variables are not declarations. + if (config.forLoopNodeTypes?.has(node.type)) { + if (config.extractForLoopBinding) { + const forLoopCtx: ForLoopExtractorContext = { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }; + config.extractForLoopBinding(node, forLoopCtx); + } + return; + } + if (config.declarationNodeTypes.has(node.type)) { + // Capture the raw type annotation AST node BEFORE extractDeclaration. + // This decouples type node capture from scopeEnv success — container types + // (User[], []User, List[User]) that fail extractSimpleTypeName still get + // their AST type node recorded for Strategy 1 for-loop resolution. + // Try direct extraction first (works for Go var_spec, Python assignment, Rust let_declaration). + // Try direct type field first, then unwrap wrapper nodes (C# field_declaration, + // local_declaration_statement wrap their type inside a variable_declaration child). + let typeNode = node.childForFieldName('type'); + if (!typeNode) { + // C# field_declaration / local_declaration_statement wrap type inside variable_declaration. + // Use manual loop instead of namedChildren.find() to avoid array allocation on hot path. + let wrapped = node.childForFieldName('declaration'); + if (!wrapped) { + for (let i = 0; i < node.namedChildCount; i++) { + const c = node.namedChild(i); + if (c?.type === 'variable_declaration') { wrapped = c; break; } + } + } + if (wrapped) typeNode = wrapped.childForFieldName('type'); + } + if (typeNode) { + const nameNode = node.childForFieldName('name') + ?? node.childForFieldName('left') + ?? node.childForFieldName('pattern'); + if (nameNode) { + const varName = extractVarName(nameNode); + if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) { + declarationTypeNodes.set(`${scope}\0${varName}`, typeNode); + } + } + } + // Run the language-specific declaration extractor (may or may not add to scopeEnv). + const keysBefore = typeNode ? new Set(scopeEnv.keys()) : undefined; + config.extractDeclaration(node, scopeEnv); + // Fallback: for multi-declarator languages (TS, C#, Java) where the type field + // is on variable_declarator children, capture via keysBefore/keysAfter diff. + if (typeNode && keysBefore) { + for (const varName of scopeEnv.keys()) { + if (!keysBefore.has(varName) && !declarationTypeNodes.has(`${scope}\0${varName}`)) { + declarationTypeNodes.set(`${scope}\0${varName}`, typeNode); + } + } + } + // Tier 1: constructor-call inference as fallback. + // Always called when available — each language's extractInitializer + // internally skips declarators that already have explicit annotations, + // so this handles mixed cases like `const a: A = x, b = new B()`. + if (config.extractInitializer) { + config.extractInitializer(node, scopeEnv, classNames); + } + } + }; + + const walk = (node: SyntaxNode, currentScope: string): void => { + // Fast skip: subtrees that can never contain type-relevant nodes (leaf-like literals). + if (SKIP_SUBTREE_TYPES.has(node.type)) return; + + // Collect class/struct names as we encounter them (used by extractInitializer + // to distinguish constructor calls from function calls, e.g. C++ `User()` vs `getUser()`) + // Currently only C++ uses this locally; other languages rely on the SymbolTable path. + if (CLASS_CONTAINER_TYPES.has(node.type)) { + // Most languages use 'name' field; Kotlin uses a type_identifier child instead + const nameNode = node.childForFieldName('name') + ?? findTypeIdentifierChild(node); + if (nameNode) localClassNames.add(nameNode.text); + } + + // Detect scope boundaries (function/method definitions) + let scope = currentScope; + if (FUNCTION_NODE_TYPES.has(node.type)) { + const { funcName } = extractFunctionName(node); + if (funcName) scope = `${funcName}@${node.startIndex}`; + } + + // Only create scope map and call extractTypeBinding for interesting node types. + // Single Set.has() replaces 3 separate checks inside extractTypeBinding. + if (interestingNodeTypes.has(node.type)) { + if (!env.has(scope)) env.set(scope, new Map()); + const scopeEnv = env.get(scope)!; + extractTypeBinding(node, scopeEnv, scope); + } + + // Pattern binding extraction: handles constructs that introduce NEW typed variables + // via pattern matching (e.g. `if let Some(x) = opt`, `x instanceof T t`). + // Runs after Tier 0/1 so scopeEnv already contains the source variable's type. + // Conservative: extractor returns undefined when source type is unknown. + if (config.extractPatternBinding && (!config.patternBindingNodeTypes || config.patternBindingNodeTypes.has(node.type))) { + // Ensure scopeEnv exists for pattern binding reads/writes + if (!env.has(scope)) env.set(scope, new Map()); + const scopeEnv = env.get(scope)!; + const patternBinding = config.extractPatternBinding(node, scopeEnv, declarationTypeNodes, scope); + if (patternBinding) { + if (config.allowPatternBindingOverwrite) { + // Position-indexed: store per-branch binding for smart-cast narrowing. + // Each when arm / switch case gets its own type for the variable, + // preventing cross-arm contamination (e.g., Kotlin when/is). + const branchNode = findPatternBranchScope(node); + if (branchNode) { + if (!patternOverrides.has(scope)) patternOverrides.set(scope, new Map()); + const varMap = patternOverrides.get(scope)!; + if (!varMap.has(patternBinding.varName)) varMap.set(patternBinding.varName, []); + varMap.get(patternBinding.varName)!.push({ + rangeStart: branchNode.startIndex, + rangeEnd: branchNode.endIndex, + typeName: patternBinding.typeName, + }); + } + // Also store in flat scopeEnv as fallback (last arm wins — same as before + // for code that doesn't use position-indexed lookup). + scopeEnv.set(patternBinding.varName, patternBinding.typeName); + } else if (!scopeEnv.has(patternBinding.varName)) { + // First-writer-wins for languages without smart-cast overwrite (Java instanceof, etc.) + scopeEnv.set(patternBinding.varName, patternBinding.typeName); + } + } + } + + // Tier 2: collect plain-identifier RHS assignments for post-walk propagation. + // Delegates to per-language extractPendingAssignment — AST shapes differ widely + // (JS uses variable_declarator/name/value, Rust uses let_declaration/pattern/value, + // Python uses assignment/left/right, Go uses short_var_declaration/expression_list). + if (config.extractPendingAssignment && config.declarationNodeTypes.has(node.type)) { + // scopeEnv is guaranteed to exist here because declarationNodeTypes is a subset + // of interestingNodeTypes, so extractTypeBinding already created the scope map above. + const scopeEnv = env.get(scope); + if (scopeEnv) { + const pending = config.extractPendingAssignment(node, scopeEnv); + if (pending) { + if (pending.kind === 'copy') { + pendingCopies.push({ scope, lhs: pending.lhs, rhs: pending.rhs }); + } else { + pendingCallResults.push({ scope, lhs: pending.lhs, callee: pending.callee }); + } + } + } + } + + // Scan for constructor bindings that couldn't be resolved locally. + // Only collect if TypeEnv didn't already resolve this binding. + if (config.scanConstructorBinding) { + const result = config.scanConstructorBinding(node); + if (result) { + const scopeEnv = env.get(scope); + if (!scopeEnv?.has(result.varName)) { + bindings.push({ scope, ...result }); + } + } + } + + // Recurse into children + for (let i = 0; i < node.childCount; i++) { + const child = node.child(i); + if (child) walk(child, scope); + } + }; + + walk(tree.rootNode, FILE_SCOPE); + + // Tier 2a: copy-propagation — `const b = a` where `a` has a known type from Tier 0/1. + // Multi-hop chains resolve when forward-declared (a→b→c in source order); + // reverse-order assignments are depth-1 only. No fixpoint iteration — + // this covers 95%+ of real-world patterns. + for (const { scope, lhs, rhs } of pendingCopies) { + const scopeEnv = env.get(scope); + if (!scopeEnv || scopeEnv.has(lhs)) continue; + const rhsType = scopeEnv.get(rhs) ?? env.get(FILE_SCOPE)?.get(rhs); + if (rhsType) scopeEnv.set(lhs, rhsType); + } + + // Tier 2b: call-result propagation — `const b = foo()` where `foo` has a declared return type. + // Uses ReturnTypeLookup which is backed by SymbolTable.lookupFuzzyCallable. + // Conservative: only binds when exactly one callable matches (avoids overload ambiguity). + // NOTE: Currently dormant — no extractPendingAssignment implementation emits 'callResult' yet. + // The loop is structurally complete and will activate when any language extractor starts + // returning { kind: 'callResult', lhs, callee } from extractPendingAssignment. + for (const { scope, lhs, callee } of pendingCallResults) { + const scopeEnv = env.get(scope); + if (!scopeEnv || scopeEnv.has(lhs)) continue; + const typeName = returnTypeLookup.lookupReturnType(callee); + if (typeName) scopeEnv.set(lhs, typeName); + } + + return { + lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides), + constructorBindings: bindings, + env, + }; +}; + +/** + * Unverified constructor binding: a `val x = Callee()` pattern where we + * couldn't confirm the callee is a class (because it's defined in another file). + * The caller must verify `calleeName` against the SymbolTable before trusting. + */ +export interface ConstructorBinding { + /** Function scope key (matches TypeEnv scope keys) */ + scope: string; + /** Variable name that received the constructor result */ + varName: string; + /** Name of the callee (potential class constructor) */ + calleeName: string; + /** Enclosing class name when callee is a method on a known receiver (e.g. $this) */ + receiverClassName?: string; +} + + diff --git a/gitnexus/src/core/ingestion/type-extractors/c-cpp.ts b/gitnexus/src/core/ingestion/type-extractors/c-cpp.ts new file mode 100644 index 0000000000..e7dacf0570 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/c-cpp.ts @@ -0,0 +1,359 @@ +import type { SyntaxNode } from '../utils.js'; +import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, PendingAssignmentExtractor, ForLoopExtractor } from './types.js'; +import { extractSimpleTypeName, extractVarName, resolveIterableElementType, methodToTypeArgPosition, type TypeArgPosition } from './shared.js'; + +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'declaration', +]); + +/** C++: Type x = ...; Type* x; Type& x; */ +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + const typeNode = node.childForFieldName('type'); + if (!typeNode) return; + const typeName = extractSimpleTypeName(typeNode); + if (!typeName) return; + + const declarator = node.childForFieldName('declarator'); + if (!declarator) return; + + // init_declarator: Type x = value + const nameNode = declarator.type === 'init_declarator' + ? declarator.childForFieldName('declarator') + : declarator; + if (!nameNode) return; + + // Handle pointer/reference declarators + const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator' + ? nameNode.firstNamedChild + : nameNode; + if (!finalName) return; + + const varName = extractVarName(finalName); + if (varName) env.set(varName, typeName); +}; + +/** C++: auto x = new User(); auto x = User(); */ +const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup): void => { + const typeNode = node.childForFieldName('type'); + if (!typeNode) return; + + // Only handle auto/placeholder — typed declarations are handled by extractDeclaration + const typeText = typeNode.text; + if ( + typeText !== 'auto' && + typeText !== 'decltype(auto)' && + typeNode.type !== 'placeholder_type_specifier' + ) return; + + const declarator = node.childForFieldName('declarator'); + if (!declarator) return; + + // Must be an init_declarator (i.e., has an initializer value) + if (declarator.type !== 'init_declarator') return; + + const value = declarator.childForFieldName('value'); + if (!value) return; + + // Resolve the variable name, unwrapping pointer/reference declarators + const nameNode = declarator.childForFieldName('declarator'); + if (!nameNode) return; + const finalName = + nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator' + ? nameNode.firstNamedChild + : nameNode; + if (!finalName) return; + const varName = extractVarName(finalName); + if (!varName) return; + + // auto x = new User() — new_expression + if (value.type === 'new_expression') { + const ctorType = value.childForFieldName('type'); + if (ctorType) { + const typeName = extractSimpleTypeName(ctorType); + if (typeName) env.set(varName, typeName); + } + return; + } + + // auto x = User() — call_expression where function is a type name + // tree-sitter-cpp may parse the constructor name as type_identifier or identifier. + // For plain identifiers, verify against known class names from the file's AST + // to distinguish constructor calls (User()) from function calls (getUser()). + if (value.type === 'call_expression') { + const func = value.childForFieldName('function'); + if (!func) return; + if (func.type === 'type_identifier') { + const typeName = func.text; + if (typeName) env.set(varName, typeName); + } else if (func.type === 'identifier') { + const text = func.text; + if (text && classNames.has(text)) env.set(varName, text); + } + return; + } + + // auto x = User{} — compound_literal_expression (brace initialization) + // AST: compound_literal_expression > type_identifier + initializer_list + if (value.type === 'compound_literal_expression') { + const typeId = value.firstNamedChild; + const typeName = typeId ? extractSimpleTypeName(typeId) : undefined; + if (typeName) env.set(varName, typeName); + } +}; + +/** C/C++: parameter_declaration → type declarator */ +const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'parameter_declaration') { + typeNode = node.childForFieldName('type'); + const declarator = node.childForFieldName('declarator'); + if (declarator) { + nameNode = declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator' + ? declarator.firstNamedChild + : declarator; + } + } else { + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** C/C++: auto x = User() where function is an identifier (not type_identifier) */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'declaration') return undefined; + const typeNode = node.childForFieldName('type'); + if (!typeNode) return undefined; + const typeText = typeNode.text; + if (typeText !== 'auto' && typeText !== 'decltype(auto)' && typeNode.type !== 'placeholder_type_specifier') return undefined; + const declarator = node.childForFieldName('declarator'); + if (!declarator || declarator.type !== 'init_declarator') return undefined; + const value = declarator.childForFieldName('value'); + if (!value || value.type !== 'call_expression') return undefined; + const func = value.childForFieldName('function'); + if (!func) return undefined; + if (func.type === 'qualified_identifier' || func.type === 'scoped_identifier') { + const last = func.lastNamedChild; + if (!last) return undefined; + const nameNode = declarator.childForFieldName('declarator'); + if (!nameNode) return undefined; + const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator' + ? nameNode.firstNamedChild : nameNode; + if (!finalName) return undefined; + return { varName: finalName.text, calleeName: last.text }; + } + if (func.type !== 'identifier') return undefined; + const nameNode = declarator.childForFieldName('declarator'); + if (!nameNode) return undefined; + const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator' + ? nameNode.firstNamedChild : nameNode; + if (!finalName) return undefined; + const varName = finalName.text; + if (!varName) return undefined; + return { varName, calleeName: func.text }; +}; + +/** C++: auto alias = user → declaration with auto type + init_declarator where value is identifier */ +const extractPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + if (node.type !== 'declaration') return undefined; + const typeNode = node.childForFieldName('type'); + if (!typeNode) return undefined; + // Only handle auto — typed declarations already resolved by extractDeclaration + const typeText = typeNode.text; + if (typeText !== 'auto' && typeText !== 'decltype(auto)' + && typeNode.type !== 'placeholder_type_specifier') return undefined; + const declarator = node.childForFieldName('declarator'); + if (!declarator || declarator.type !== 'init_declarator') return undefined; + const value = declarator.childForFieldName('value'); + if (!value || value.type !== 'identifier') return undefined; + const nameNode = declarator.childForFieldName('declarator'); + if (!nameNode) return undefined; + const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator' + ? nameNode.firstNamedChild : nameNode; + if (!finalName) return undefined; + const lhs = extractVarName(finalName); + if (!lhs || scopeEnv.has(lhs)) return undefined; + return { kind: 'copy', lhs, rhs: value.text }; +}; + +// --- For-loop Tier 1c --- + +const FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set(['for_range_loop']); + +/** Extract template type arguments from a C++ template_type node. + * C++ template_type uses template_argument_list (not type_arguments), and each + * argument is a type_descriptor with a 'type' field containing the type_specifier. */ +const extractCppTemplateTypeArgs = (templateTypeNode: SyntaxNode): string[] => { + const argsNode = templateTypeNode.childForFieldName('arguments'); + if (!argsNode || argsNode.type !== 'template_argument_list') return []; + const result: string[] = []; + for (let i = 0; i < argsNode.namedChildCount; i++) { + let argNode = argsNode.namedChild(i); + if (!argNode) continue; + // type_descriptor wraps the actual type specifier in a 'type' field + if (argNode.type === 'type_descriptor') { + const inner = argNode.childForFieldName('type'); + if (inner) argNode = inner; + } + const name = extractSimpleTypeName(argNode); + if (name) result.push(name); + } + return result; +}; + +/** Extract element type from a C++ type annotation AST node. + * Handles: template_type (vector<User>, map<string, User>), + * pointer/reference types (User*, User&). */ +const extractCppElementTypeFromTypeNode = (typeNode: SyntaxNode, pos: TypeArgPosition = 'last', depth = 0): string | undefined => { + if (depth > 50) return undefined; + // template_type: vector<User>, map<string, User> — extract type arg based on position + if (typeNode.type === 'template_type') { + const args = extractCppTemplateTypeArgs(typeNode); + if (args.length >= 1) return pos === 'first' ? args[0] : args[args.length - 1]; + } + // reference/pointer types: unwrap and recurse (vector<User>& → vector<User>) + if (typeNode.type === 'reference_type' || typeNode.type === 'pointer_type' + || typeNode.type === 'type_descriptor') { + const inner = typeNode.lastNamedChild; + if (inner) return extractCppElementTypeFromTypeNode(inner, pos, depth + 1); + } + // qualified/scoped types: std::vector<User> → unwrap to template_type child + if (typeNode.type === 'qualified_identifier' || typeNode.type === 'scoped_type_identifier') { + const inner = typeNode.lastNamedChild; + if (inner) return extractCppElementTypeFromTypeNode(inner, pos, depth + 1); + } + return undefined; +}; + +/** Walk up from a for-range-loop to the enclosing function_definition and search parameters + * for one named `iterableName`. Returns the element type from its annotation. */ +const findCppParamElementType = (iterableName: string, startNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (current.type === 'function_definition') { + const declarator = current.childForFieldName('declarator'); + // function_definition > declarator (function_declarator) > parameters (parameter_list) + const paramsNode = declarator?.childForFieldName('parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const param = paramsNode.namedChild(i); + if (!param || param.type !== 'parameter_declaration') continue; + const paramDeclarator = param.childForFieldName('declarator'); + if (!paramDeclarator) continue; + // Unwrap reference/pointer declarators: vector<User>& users → &users + let identNode = paramDeclarator; + if (identNode.type === 'reference_declarator' || identNode.type === 'pointer_declarator') { + identNode = identNode.firstNamedChild ?? identNode; + } + if (identNode.text !== iterableName) continue; + const typeNode = param.childForFieldName('type'); + if (typeNode) return extractCppElementTypeFromTypeNode(typeNode, pos); + } + } + break; + } + current = current.parent; + } + return undefined; +}; + +/** C++: for (auto& user : users) — extract loop variable binding. + * Handles explicit types (for (User& user : users)) and auto (for (auto& user : users)). + * For auto, resolves element type from the iterable's container type. */ +const extractForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope } ): void => { + if (node.type !== 'for_range_loop') return; + + const typeNode = node.childForFieldName('type'); + const declaratorNode = node.childForFieldName('declarator'); + const rightNode = node.childForFieldName('right'); + if (!typeNode || !declaratorNode || !rightNode) return; + + // Unwrap reference/pointer declarator to get the loop variable name + let nameNode = declaratorNode; + if (nameNode.type === 'reference_declarator' || nameNode.type === 'pointer_declarator') { + nameNode = nameNode.firstNamedChild ?? nameNode; + } + + // Handle structured bindings: auto& [key, value] or auto [key, value] + // Bind the last identifier (value heuristic for [key, value] patterns) + let loopVarName: string | undefined; + if (nameNode.type === 'structured_binding_declarator') { + const lastChild = nameNode.lastNamedChild; + if (lastChild?.type === 'identifier') { + loopVarName = lastChild.text; + } + } else if (declaratorNode.type === 'structured_binding_declarator') { + const lastChild = declaratorNode.lastNamedChild; + if (lastChild?.type === 'identifier') { + loopVarName = lastChild.text; + } + } + + const varName = loopVarName ?? extractVarName(nameNode); + if (!varName) return; + + // Check if the type is auto/placeholder — if not, use the explicit type directly + const isAuto = typeNode.type === 'placeholder_type_specifier' + || typeNode.text === 'auto' + || typeNode.text === 'const auto' + || typeNode.text === 'decltype(auto)'; + + if (!isAuto) { + // Explicit type: for (User& user : users) — extract directly + const typeName = extractSimpleTypeName(typeNode); + if (typeName) scopeEnv.set(varName, typeName); + return; + } + + // auto/const auto/auto& — resolve from the iterable's container type + // Extract iterable name + optional method + let iterableName: string | undefined; + let methodName: string | undefined; + if (rightNode.type === 'identifier') { + iterableName = rightNode.text; + } else if (rightNode.type === 'field_expression') { + const prop = rightNode.lastNamedChild; + if (prop) iterableName = prop.text; + } else if (rightNode.type === 'call_expression') { + // users.begin() is NOT used in range-for, but container.items() etc. might be + const fieldExpr = rightNode.childForFieldName('function'); + if (fieldExpr?.type === 'field_expression') { + const obj = fieldExpr.firstNamedChild; + if (obj?.type === 'identifier') iterableName = obj.text; + const field = fieldExpr.lastNamedChild; + if (field?.type === 'field_identifier') methodName = field.text; + } + } else if (rightNode.type === 'pointer_expression') { + // Dereference: for (auto& user : *ptr) → pointer_expression > identifier + // Only handles simple *identifier; *this->field and **ptr are not resolved. + const operand = rightNode.lastNamedChild; + if (operand?.type === 'identifier') iterableName = operand.text; + } + if (!iterableName) return; + + const containerTypeName = scopeEnv.get(iterableName); + const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName); + const elementType = resolveIterableElementType( + iterableName, node, scopeEnv, declarationTypeNodes, scope, + extractCppElementTypeFromTypeNode, findCppParamElementType, + typeArgPos, + ); + if (elementType) scopeEnv.set(varName, elementType); +}; + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + forLoopNodeTypes: FOR_LOOP_NODE_TYPES, + extractDeclaration, + extractParameter, + extractInitializer, + scanConstructorBinding, + extractForLoopBinding, + extractPendingAssignment, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/csharp.ts b/gitnexus/src/core/ingestion/type-extractors/csharp.ts new file mode 100644 index 0000000000..e2a15ceb57 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/csharp.ts @@ -0,0 +1,344 @@ +import type { SyntaxNode } from '../utils.js'; +import type { ConstructorBindingScanner, ForLoopExtractor, LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, PendingAssignmentExtractor, PatternBindingExtractor } from './types.js'; +import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, type TypeArgPosition } from './shared.js'; + +/** Known container property accessors that operate on the container itself (e.g., dict.Keys, dict.Values) */ +const KNOWN_CONTAINER_PROPS: ReadonlySet<string> = new Set(['Keys', 'Values']); + +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'local_declaration_statement', + 'variable_declaration', + 'field_declaration', +]); + +/** C#: Type x = ...; var x = new Type(); */ +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + // C# tree-sitter: local_declaration_statement > variable_declaration > ... + // Recursively descend through wrapper nodes + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (!child) continue; + if (child.type === 'variable_declaration' || child.type === 'local_declaration_statement') { + extractDeclaration(child, env); + return; + } + } + + // At variable_declaration level: first child is type, rest are variable_declarators + let typeNode: SyntaxNode | null = null; + const declarators: SyntaxNode[] = []; + + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (!child) continue; + + if (!typeNode && child.type !== 'variable_declarator' && child.type !== 'equals_value_clause') { + // First non-declarator child is the type (identifier, implicit_type, generic_name, etc.) + typeNode = child; + } + if (child.type === 'variable_declarator') { + declarators.push(child); + } + } + + if (!typeNode || declarators.length === 0) return; + + // Handle 'var x = new Foo()' — infer from object_creation_expression + let typeName: string | undefined; + if (typeNode.type === 'implicit_type' && typeNode.text === 'var') { + // Try to infer from initializer: var x = new Foo() + // tree-sitter-c-sharp may put object_creation_expression as direct child + // or inside equals_value_clause depending on grammar version + if (declarators.length === 1) { + const initializer = findChildByType(declarators[0], 'object_creation_expression') + ?? findChildByType(declarators[0], 'equals_value_clause')?.firstNamedChild; + if (initializer?.type === 'object_creation_expression') { + const ctorType = initializer.childForFieldName('type'); + if (ctorType) typeName = extractSimpleTypeName(ctorType); + } + } + } else { + typeName = extractSimpleTypeName(typeNode); + } + + if (!typeName) return; + for (const decl of declarators) { + const nameNode = decl.childForFieldName('name') ?? decl.firstNamedChild; + if (nameNode) { + const varName = extractVarName(nameNode); + if (varName) env.set(varName, typeName); + } + } +}; + +/** C#: parameter → type name */ +const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'parameter') { + typeNode = node.childForFieldName('type'); + nameNode = node.childForFieldName('name'); + } else { + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** C#: var x = SomeFactory(...) → bind x to SomeFactory (constructor-like call) */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'variable_declaration') return undefined; + // Find type and declarator children by iterating (C# grammar doesn't expose 'type' as a named field) + let typeNode: SyntaxNode | null = null; + let declarator: SyntaxNode | null = null; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (!child) continue; + if (child.type === 'variable_declarator') { if (!declarator) declarator = child; } + else if (!typeNode) { typeNode = child; } + } + // Only handle implicit_type (var) — explicit types handled by extractDeclaration + if (!typeNode || typeNode.type !== 'implicit_type') return undefined; + if (!declarator) return undefined; + const nameNode = declarator.childForFieldName('name') ?? declarator.firstNamedChild; + if (!nameNode || nameNode.type !== 'identifier') return undefined; + // Find the initializer value: either inside equals_value_clause or as a direct child + // (tree-sitter-c-sharp puts invocation_expression directly inside variable_declarator) + let value: SyntaxNode | null = null; + for (let i = 0; i < declarator.namedChildCount; i++) { + const child = declarator.namedChild(i); + if (!child) continue; + if (child.type === 'equals_value_clause') { value = child.firstNamedChild; break; } + if (child.type === 'invocation_expression' || child.type === 'object_creation_expression' || child.type === 'await_expression') { value = child; break; } + } + if (!value) return undefined; + // Unwrap await: `var user = await svc.GetUserAsync()` → await_expression wraps invocation_expression + value = unwrapAwait(value); + if (!value) return undefined; + // Skip object_creation_expression (new User()) — handled by extractInitializer + if (value.type === 'object_creation_expression') return undefined; + if (value.type !== 'invocation_expression') return undefined; + const func = value.firstNamedChild; + if (!func) return undefined; + const calleeName = extractSimpleTypeName(func); + if (!calleeName) return undefined; + return { varName: nameNode.text, calleeName }; +}; + +const FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set([ + 'foreach_statement', +]); + +/** Extract element type from a C# type annotation AST node. + * Handles generic_name (List<User>), array_type (User[]), nullable_type (?). + * `pos` selects which type arg: 'first' for keys, 'last' for values (default). */ +const extractCSharpElementTypeFromTypeNode = (typeNode: SyntaxNode, pos: TypeArgPosition = 'last', depth = 0): string | undefined => { + if (depth > 50) return undefined; + // generic_name: List<User>, IEnumerable<User>, Dictionary<string, User> + // C# uses generic_name (not generic_type) + if (typeNode.type === 'generic_name') { + const argList = findChildByType(typeNode, 'type_argument_list'); + if (argList && argList.namedChildCount >= 1) { + if (pos === 'first') { + const firstArg = argList.namedChild(0); + if (firstArg) return extractSimpleTypeName(firstArg); + } else { + const lastArg = argList.namedChild(argList.namedChildCount - 1); + if (lastArg) return extractSimpleTypeName(lastArg); + } + } + } + // array_type: User[] + if (typeNode.type === 'array_type') { + const elemNode = typeNode.firstNamedChild; + if (elemNode) return extractSimpleTypeName(elemNode); + } + // nullable_type: unwrap and recurse (List<User>? → List<User> → User) + if (typeNode.type === 'nullable_type') { + const inner = typeNode.firstNamedChild; + if (inner) return extractCSharpElementTypeFromTypeNode(inner, pos, depth + 1); + } + return undefined; +}; + +/** Walk up from a foreach to the enclosing method and search parameters. */ +const findCSharpParamElementType = (iterableName: string, startNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (current.type === 'method_declaration' || current.type === 'local_function_statement') { + const paramsNode = current.childForFieldName('parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const param = paramsNode.namedChild(i); + if (!param || param.type !== 'parameter') continue; + const nameNode = param.childForFieldName('name'); + if (nameNode?.text !== iterableName) continue; + const typeNode = param.childForFieldName('type'); + if (typeNode) return extractCSharpElementTypeFromTypeNode(typeNode, pos); + } + } + break; + } + current = current.parent; + } + return undefined; +}; + +/** C#: foreach (User user in users) — extract loop variable binding. + * Tier 1c: for `foreach (var user in users)`, resolves element type from iterable. */ +const extractForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }): void => { + const typeNode = node.childForFieldName('type'); + const nameNode = node.childForFieldName('left'); + if (!typeNode || !nameNode) return; + const varName = extractVarName(nameNode); + if (!varName) return; + + // Explicit type (existing behavior): foreach (User user in users) + if (!(typeNode.type === 'implicit_type' && typeNode.text === 'var')) { + const typeName = extractSimpleTypeName(typeNode); + if (typeName) scopeEnv.set(varName, typeName); + return; + } + + // Tier 1c: implicit type (var) — resolve from iterable's container type + const rightNode = node.childForFieldName('right'); + let iterableName: string | undefined; + let methodName: string | undefined; + let callExprElementType: string | undefined; + + if (rightNode?.type === 'identifier') { + iterableName = rightNode.text; + } else if (rightNode?.type === 'member_access_expression') { + // C# property access: data.Keys, data.Values → member_access_expression + // Also handles bare member access: this.users, repo.users → use property as iterableName + const obj = rightNode.childForFieldName('expression'); + const prop = rightNode.childForFieldName('name'); + const propText = prop?.type === 'identifier' ? prop.text : undefined; + if (propText && KNOWN_CONTAINER_PROPS.has(propText)) { + if (obj?.type === 'identifier') { + iterableName = obj.text; + } else if (obj?.type === 'member_access_expression') { + // Nested member access: this.data.Values → obj is "this.data", extract "data" + const innerProp = obj.childForFieldName('name'); + if (innerProp) iterableName = innerProp.text; + } + methodName = propText; + } else if (propText) { + // Bare member access: this.users → use property name for scopeEnv lookup + iterableName = propText; + } + } else if (rightNode?.type === 'invocation_expression') { + // C# method call: data.Select(...) → invocation_expression > member_access_expression + // Direct function call: GetUsers() → invocation_expression > identifier + const fn = rightNode.firstNamedChild; + if (fn?.type === 'member_access_expression') { + const obj = fn.childForFieldName('expression'); + const prop = fn.childForFieldName('name'); + if (obj?.type === 'identifier') iterableName = obj.text; + if (prop?.type === 'identifier') methodName = prop.text; + } else if (fn?.type === 'identifier') { + // Direct function call: foreach (var u in GetUsers()) + const rawReturn = returnTypeLookup.lookupRawReturnType(fn.text); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + } + if (!iterableName && !callExprElementType) return; + + let elementType: string | undefined; + if (callExprElementType) { + elementType = callExprElementType; + } else { + const containerTypeName = scopeEnv.get(iterableName!); + const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName); + elementType = resolveIterableElementType( + iterableName!, node, scopeEnv, declarationTypeNodes, scope, + extractCSharpElementTypeFromTypeNode, findCSharpParamElementType, + typeArgPos, + ); + } + if (elementType) scopeEnv.set(varName, elementType); +}; + +/** + * C# pattern binding extractor for `obj is Type variable` (type pattern). + * + * AST structure: + * is_pattern_expression + * expression: (the variable being tested) + * pattern: declaration_pattern + * type: (the declared type) + * name: single_variable_designation > identifier (the new variable name) + * + * Conservative: returns undefined when the pattern field is absent, is not a + * declaration_pattern, or when the type/name cannot be extracted. + * No scopeEnv lookup is needed — the pattern explicitly declares the new variable's type. + */ +const extractPatternBinding: PatternBindingExtractor = (node) => { + // is_pattern_expression: `obj is User user` — has a declaration_pattern child + if (node.type === 'is_pattern_expression') { + const pattern = node.childForFieldName('pattern'); + if (pattern?.type !== 'declaration_pattern' && pattern?.type !== 'recursive_pattern') return undefined; + const typeNode = pattern.childForFieldName('type'); + const nameNode = pattern.childForFieldName('name'); + if (!typeNode || !nameNode) return undefined; + const typeName = extractSimpleTypeName(typeNode); + const varName = extractVarName(nameNode); + if (!typeName || !varName) return undefined; + return { varName, typeName }; + } + // declaration_pattern / recursive_pattern: standalone in switch statements and switch expressions + // `case User u:` or `User u =>` or `User { Name: "Alice" } u =>` + // Both use the same 'type' and 'name' fields. + if (node.type === 'declaration_pattern' || node.type === 'recursive_pattern') { + const typeNode = node.childForFieldName('type'); + const nameNode = node.childForFieldName('name'); + if (!typeNode || !nameNode) return undefined; + const typeName = extractSimpleTypeName(typeNode); + const varName = extractVarName(nameNode); + if (!typeName || !varName) return undefined; + return { varName, typeName }; + } + return undefined; +}; + +/** C#: var alias = u → variable_declarator with name + equals_value_clause. + * Only local_declaration_statement and variable_declaration contain variable_declarator children; + * is_pattern_expression and field_declaration never do — skip them early. */ +const extractPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + if (node.type === 'is_pattern_expression' || node.type === 'field_declaration') return undefined; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (!child || child.type !== 'variable_declarator') continue; + const nameNode = child.childForFieldName('name'); + if (!nameNode) continue; + const lhs = nameNode.text; + if (scopeEnv.has(lhs)) continue; + // C# wraps value in equals_value_clause; fall back to last named child + let evc: SyntaxNode | null = null; + for (let j = 0; j < child.childCount; j++) { + if (child.child(j)?.type === 'equals_value_clause') { evc = child.child(j); break; } + } + const valueNode = evc?.firstNamedChild ?? child.namedChild(child.namedChildCount - 1); + if (valueNode && valueNode !== nameNode && (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')) { + return { kind: 'copy', lhs, rhs: valueNode.text }; + } + } + return undefined; +}; + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + forLoopNodeTypes: FOR_LOOP_NODE_TYPES, + patternBindingNodeTypes: new Set(['is_pattern_expression', 'declaration_pattern', 'recursive_pattern']), + extractDeclaration, + extractParameter, + scanConstructorBinding, + extractForLoopBinding, + extractPendingAssignment, + extractPatternBinding, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/go.ts b/gitnexus/src/core/ingestion/type-extractors/go.ts new file mode 100644 index 0000000000..e5d6893154 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/go.ts @@ -0,0 +1,438 @@ +import type { SyntaxNode } from '../utils.js'; +import type { ConstructorBindingScanner, ForLoopExtractor, LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, PendingAssignmentExtractor } from './types.js'; +import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, extractGenericTypeArgs, findChildByType, resolveIterableElementType, methodToTypeArgPosition, type TypeArgPosition } from './shared.js'; + +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'var_declaration', + 'var_spec', + 'short_var_declaration', +]); + +/** Go: var x Foo */ +const extractGoVarDeclaration = (node: SyntaxNode, env: Map<string, string>): void => { + // Go var_declaration contains var_spec children + if (node.type === 'var_declaration') { + for (let i = 0; i < node.namedChildCount; i++) { + const spec = node.namedChild(i); + if (spec?.type === 'var_spec') extractGoVarDeclaration(spec, env); + } + return; + } + + // var_spec: name type [= value] + const nameNode = node.childForFieldName('name'); + const typeNode = node.childForFieldName('type'); + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Go: x := Foo{...} — infer type from composite literal (handles multi-assignment) */ +const extractGoShortVarDeclaration = (node: SyntaxNode, env: Map<string, string>): void => { + const left = node.childForFieldName('left'); + const right = node.childForFieldName('right'); + if (!left || !right) return; + + // Collect LHS names and RHS values (may be expression_lists for multi-assignment) + const lhsNodes: SyntaxNode[] = []; + const rhsNodes: SyntaxNode[] = []; + + if (left.type === 'expression_list') { + for (let i = 0; i < left.namedChildCount; i++) { + const c = left.namedChild(i); + if (c) lhsNodes.push(c); + } + } else { + lhsNodes.push(left); + } + + if (right.type === 'expression_list') { + for (let i = 0; i < right.namedChildCount; i++) { + const c = right.namedChild(i); + if (c) rhsNodes.push(c); + } + } else { + rhsNodes.push(right); + } + + // Pair each LHS name with its corresponding RHS value + const count = Math.min(lhsNodes.length, rhsNodes.length); + for (let i = 0; i < count; i++) { + let valueNode = rhsNodes[i]; + // Unwrap &User{} — unary_expression (address-of) wrapping composite_literal + if (valueNode.type === 'unary_expression' && valueNode.firstNamedChild?.type === 'composite_literal') { + valueNode = valueNode.firstNamedChild; + } + // Go built-in new(User) — call_expression with 'new' callee and type argument + // Go built-in make([]User, 0) / make(map[string]User) — extract element/value type + if (valueNode.type === 'call_expression') { + const funcNode = valueNode.childForFieldName('function'); + if (funcNode?.text === 'new') { + const args = valueNode.childForFieldName('arguments'); + if (args?.firstNamedChild) { + const typeName = extractSimpleTypeName(args.firstNamedChild); + const varName = extractVarName(lhsNodes[i]); + if (varName && typeName) env.set(varName, typeName); + } + } else if (funcNode?.text === 'make') { + const args = valueNode.childForFieldName('arguments'); + const firstArg = args?.firstNamedChild; + if (firstArg) { + let innerType: SyntaxNode | null = null; + if (firstArg.type === 'slice_type') { + innerType = firstArg.childForFieldName('element'); + } else if (firstArg.type === 'map_type') { + innerType = firstArg.childForFieldName('value'); + } + if (innerType) { + const typeName = extractSimpleTypeName(innerType); + const varName = extractVarName(lhsNodes[i]); + if (varName && typeName) env.set(varName, typeName); + } + } + } + continue; + } + // Go type assertion: user := iface.(User) — type_assertion_expression with 'type' field + if (valueNode.type === 'type_assertion_expression') { + const typeNode = valueNode.childForFieldName('type'); + if (typeNode) { + const typeName = extractSimpleTypeName(typeNode); + const varName = extractVarName(lhsNodes[i]); + if (varName && typeName) env.set(varName, typeName); + } + continue; + } + if (valueNode.type !== 'composite_literal') continue; + const typeNode = valueNode.childForFieldName('type'); + if (!typeNode) continue; + const typeName = extractSimpleTypeName(typeNode); + if (!typeName) continue; + const varName = extractVarName(lhsNodes[i]); + if (varName) env.set(varName, typeName); + } +}; + +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + if (node.type === 'var_declaration' || node.type === 'var_spec') { + extractGoVarDeclaration(node, env); + } else if (node.type === 'short_var_declaration') { + extractGoShortVarDeclaration(node, env); + } +}; + +/** Go: parameter → name type */ +const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'parameter') { + nameNode = node.childForFieldName('name'); + typeNode = node.childForFieldName('type'); + } else { + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Go: user := NewUser(...) — infer type from single-assignment call expression */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'short_var_declaration') return undefined; + const left = node.childForFieldName('left'); + const right = node.childForFieldName('right'); + if (!left || !right) return undefined; + const leftIds = left.type === 'expression_list' ? left.namedChildren : [left]; + const rightExprs = right.type === 'expression_list' ? right.namedChildren : [right]; + + // Multi-return: user, err := NewUser() — bind first var when second is err/ok/_ + if (leftIds.length === 2 && rightExprs.length === 1) { + const secondVar = leftIds[1]; + const isErrorOrDiscard = + secondVar.text === '_' || + secondVar.text === 'err' || + secondVar.text === 'ok' || + secondVar.text === 'error'; + if (isErrorOrDiscard && leftIds[0].type === 'identifier') { + if (rightExprs[0].type !== 'call_expression') return undefined; + const func = rightExprs[0].childForFieldName('function'); + if (!func) return undefined; + if (func.text === 'new' || func.text === 'make') return undefined; + const calleeName = extractSimpleTypeName(func); + if (!calleeName) return undefined; + return { varName: leftIds[0].text, calleeName }; + } + } + + // Single assignment only + if (leftIds.length !== 1 || leftIds[0].type !== 'identifier') return undefined; + if (rightExprs.length !== 1 || rightExprs[0].type !== 'call_expression') return undefined; + const func = rightExprs[0].childForFieldName('function'); + if (!func) return undefined; + // Skip new() and make() — already handled by extractDeclaration + if (func.text === 'new' || func.text === 'make') return undefined; + const calleeName = extractSimpleTypeName(func); + if (!calleeName) return undefined; + return { varName: leftIds[0].text, calleeName }; +}; + +const FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set([ + 'for_statement', +]); + +/** Go function/method node types that carry a parameter list. */ +const GO_FUNCTION_NODE_TYPES = new Set([ + 'function_declaration', 'method_declaration', 'func_literal', +]); + +/** + * Extract element type from a Go type annotation AST node. + * Handles: + * slice_type "[]User" → element field → type_identifier "User" + * array_type "[10]User" → element field → type_identifier "User" + * Falls back to text-based extraction via extractElementTypeFromString. + */ +const extractGoElementTypeFromTypeNode = (typeNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + // slice_type: []User — element field is the element type + if (typeNode.type === 'slice_type' || typeNode.type === 'array_type') { + const elemNode = typeNode.childForFieldName('element'); + if (elemNode) return extractSimpleTypeName(elemNode); + } + // map_type: map[string]User — value field is the element type (for range, second var gets value) + if (typeNode.type === 'map_type') { + const valueNode = typeNode.childForFieldName('value'); + if (valueNode) return extractSimpleTypeName(valueNode); + } + // channel_type: chan User — the type argument is the element type + if (typeNode.type === 'channel_type') { + const valueNode = typeNode.childForFieldName('value') ?? typeNode.lastNamedChild; + if (valueNode) return extractSimpleTypeName(valueNode); + } + // generic_type: Go 1.18+ generics (e.g., MySlice[User], Cache[string, User]) + // Use position-aware arg selection: 'first' for keys, 'last' for values. + if (typeNode.type === 'generic_type') { + const args = extractGenericTypeArgs(typeNode); + if (args.length >= 1) return pos === 'first' ? args[0] : args[args.length - 1]; + } + // Fallback: text-based extraction ([]User → User, User[] → User) + return extractElementTypeFromString(typeNode.text, pos); +}; + +/** Check if a Go type node represents a channel type. Used to determine + * whether single-var range yields the element (channels) vs index (slices/maps). */ +const isChannelType = ( + iterableName: string, + scopeEnv: ReadonlyMap<string, string>, + declarationTypeNodes?: ReadonlyMap<string, SyntaxNode>, + scope?: string, +): boolean => { + if (declarationTypeNodes && scope) { + const typeNode = declarationTypeNodes.get(`${scope}\0${iterableName}`); + if (typeNode) return typeNode.type === 'channel_type'; + } + const t = scopeEnv.get(iterableName); + return !!t && t.startsWith('chan '); +}; + +/** + * Walk up the AST from a for-statement to find the enclosing function declaration, + * then search its parameters for one named `iterableName`. + * Returns the element type extracted from its type annotation, or undefined. + * + * Go parameter_declaration has: + * name field: identifier (the parameter name) + * type field: the type node (slice_type for []User) + */ +const findGoParamElementType = (iterableName: string, startNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (GO_FUNCTION_NODE_TYPES.has(current.type)) { + const paramsNode = current.childForFieldName('parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const paramDecl = paramsNode.namedChild(i); + if (!paramDecl || paramDecl.type !== 'parameter_declaration') continue; + // parameter_declaration: name type — name field is the identifier + const nameNode = paramDecl.childForFieldName('name'); + if (nameNode?.text === iterableName) { + const typeNode = paramDecl.childForFieldName('type'); + if (typeNode) return extractGoElementTypeFromTypeNode(typeNode, pos); + } + } + } + break; + } + current = current.parent; + } + return undefined; +}; + +/** + * Go: for _, user := range users where users has a known slice type. + * + * Go uses a single `for_statement` node for all for-loop forms. We detect + * range-based loops by looking for a `range_clause` child node. C-style for + * loops (with `for_clause`) and infinite loops (no clause) are ignored. + * + * Tier 1c: resolves the element type via three strategies in priority order: + * 1. declarationTypeNodes — raw type annotation AST node + * 2. scopeEnv string — extractElementTypeFromString on the stored type + * 3. AST walk — walks up to the enclosing function's parameters to read []User directly + * For `_, user := range users`, the loop variable is the second identifier in + * the `left` expression_list (index is discarded, value is the element). + */ +const extractForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }): void => { + if (node.type !== 'for_statement') return; + + // Find the range_clause child — this distinguishes range loops from other for forms. + let rangeClause: SyntaxNode | null = null; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === 'range_clause') { + rangeClause = child; + break; + } + } + if (!rangeClause) return; + + // The iterable is the `right` field of the range_clause. + const rightNode = rangeClause.childForFieldName('right'); + let iterableName: string | undefined; + let callExprElementType: string | undefined; + if (rightNode?.type === 'identifier') { + iterableName = rightNode.text; + } else if (rightNode?.type === 'selector_expression') { + const field = rightNode.childForFieldName('field'); + if (field) iterableName = field.text; + } else if (rightNode?.type === 'call_expression') { + // Range over a call result: `for _, v := range getItems()` or `for _, v := range repo.All()` + const funcNode = rightNode.childForFieldName('function'); + let callee: string | undefined; + if (funcNode?.type === 'identifier') { + callee = funcNode.text; + } else if (funcNode?.type === 'selector_expression') { + const field = funcNode.childForFieldName('field'); + if (field) callee = field.text; + } + if (callee) { + const rawReturn = returnTypeLookup.lookupRawReturnType(callee); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + } + if (!iterableName && !callExprElementType) return; + + let elementType: string | undefined; + if (callExprElementType) { + elementType = callExprElementType; + } else { + const containerTypeName = scopeEnv.get(iterableName!); + const typeArgPos = methodToTypeArgPosition(undefined, containerTypeName); + elementType = resolveIterableElementType( + iterableName!, node, scopeEnv, declarationTypeNodes, scope, + extractGoElementTypeFromTypeNode, findGoParamElementType, + typeArgPos, + ); + } + if (!elementType) return; + + // The loop variable(s) are in the `left` field. + // Go range semantics: + // Slice/Array/String: single-var → INDEX (int); two-var → (index, element) + // Map: single-var → KEY; two-var → (key, value) + // Channel: single-var → ELEMENT (channels have no index) + const leftNode = rangeClause.childForFieldName('left'); + if (!leftNode) return; + + let loopVarNode: SyntaxNode | null = null; + if (leftNode.type === 'expression_list') { + if (leftNode.namedChildCount >= 2) { + // Two-var form: `_, user` or `i, user` — second variable gets element/value type + loopVarNode = leftNode.namedChild(1); + } else { + // Single-var in expression_list — yields INDEX for slices/maps, ELEMENT for channels. + // For call-expression iterables (iterableName undefined), conservative: treat as non-channel. + // Channels are rarely returned from function calls, and even if they were, skipping here + // just means we miss a binding rather than create an incorrect one. + if (iterableName && isChannelType(iterableName, scopeEnv, declarationTypeNodes, scope)) { + loopVarNode = leftNode.namedChild(0); + } else { + return; // index-only range on slice/map — skip + } + } + } else { + // Plain identifier (single-var form without expression_list) + // For call-expression iterables (iterableName undefined), conservative: treat as non-channel. + // Channels are rarely returned from function calls, and even if they were, skipping here + // just means we miss a binding rather than create an incorrect one. + if (iterableName && isChannelType(iterableName, scopeEnv, declarationTypeNodes, scope)) { + loopVarNode = leftNode; + } else { + return; // index-only range on slice/map — skip + } + } + if (!loopVarNode) return; + + // Skip the blank identifier `_` + if (loopVarNode.text === '_') return; + + const loopVarName = extractVarName(loopVarNode); + if (loopVarName) scopeEnv.set(loopVarName, elementType); +}; + +/** Go: alias := u (short_var_declaration) or var b = u (var_spec) */ +const extractPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + if (node.type === 'short_var_declaration') { + const left = node.childForFieldName('left'); + const right = node.childForFieldName('right'); + if (!left || !right) return undefined; + const lhsNode = left.type === 'expression_list' ? left.firstNamedChild : left; + const rhsNode = right.type === 'expression_list' ? right.firstNamedChild : right; + if (!lhsNode || !rhsNode) return undefined; + if (lhsNode.type !== 'identifier') return undefined; + const lhs = lhsNode.text; + if (scopeEnv.has(lhs)) return undefined; + if (rhsNode.type === 'identifier') return { kind: 'copy', lhs, rhs: rhsNode.text }; + return undefined; + } + if (node.type === 'var_spec' || node.type === 'var_declaration') { + // var_declaration contains var_spec children; var_spec has name + expression_list value + const specs: SyntaxNode[] = []; + if (node.type === 'var_declaration') { + for (let i = 0; i < node.namedChildCount; i++) { + const c = node.namedChild(i); + if (c?.type === 'var_spec') specs.push(c); + } + } else { + specs.push(node); + } + for (const spec of specs) { + const nameNode = spec.childForFieldName('name'); + if (!nameNode || nameNode.type !== 'identifier') continue; + const lhs = nameNode.text; + if (scopeEnv.has(lhs)) continue; + // Check if the last named child is a bare identifier (no type annotation between name and value) + let exprList: SyntaxNode | null = null; + for (let i = 0; i < spec.childCount; i++) { + if (spec.child(i)?.type === 'expression_list') { exprList = spec.child(i); break; } + } + const rhsNode = exprList?.firstNamedChild; + if (rhsNode?.type === 'identifier') return { kind: 'copy', lhs, rhs: rhsNode.text }; + } + } + return undefined; +}; + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + forLoopNodeTypes: FOR_LOOP_NODE_TYPES, + extractDeclaration, + extractParameter, + scanConstructorBinding, + extractForLoopBinding, + extractPendingAssignment, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/index.ts b/gitnexus/src/core/ingestion/type-extractors/index.ts new file mode 100644 index 0000000000..b8705fc2e0 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/index.ts @@ -0,0 +1,52 @@ +/** + * Per-language type extraction configurations. + * Assembled here into a dispatch map keyed by SupportedLanguages. + */ + +import { SupportedLanguages } from '../../../config/supported-languages.js'; +import type { LanguageTypeConfig } from './types.js'; + +import { typeConfig as typescriptConfig } from './typescript.js'; +import { javaTypeConfig, kotlinTypeConfig } from './jvm.js'; +import { typeConfig as csharpConfig } from './csharp.js'; +import { typeConfig as goConfig } from './go.js'; +import { typeConfig as rustConfig } from './rust.js'; +import { typeConfig as pythonConfig } from './python.js'; +import { typeConfig as swiftConfig } from './swift.js'; +import { typeConfig as cCppConfig } from './c-cpp.js'; +import { typeConfig as phpConfig } from './php.js'; +import { typeConfig as rubyConfig } from './ruby.js'; + +export const typeConfigs = { + [SupportedLanguages.JavaScript]: typescriptConfig, + [SupportedLanguages.TypeScript]: typescriptConfig, + [SupportedLanguages.Java]: javaTypeConfig, + [SupportedLanguages.Kotlin]: kotlinTypeConfig, + [SupportedLanguages.CSharp]: csharpConfig, + [SupportedLanguages.Go]: goConfig, + [SupportedLanguages.Rust]: rustConfig, + [SupportedLanguages.Python]: pythonConfig, + [SupportedLanguages.Swift]: swiftConfig, + [SupportedLanguages.C]: cCppConfig, + [SupportedLanguages.CPlusPlus]: cCppConfig, + [SupportedLanguages.PHP]: phpConfig, + [SupportedLanguages.Ruby]: rubyConfig, +} satisfies Record<SupportedLanguages, LanguageTypeConfig>; + +export type { + LanguageTypeConfig, + TypeBindingExtractor, + ParameterExtractor, + ConstructorBindingScanner, + ForLoopExtractor, + PendingAssignmentExtractor, + PatternBindingExtractor, +} from './types.js'; +export { + TYPED_PARAMETER_TYPES, + extractSimpleTypeName, + extractGenericTypeArgs, + extractVarName, + findChildByType, + extractRubyConstructorAssignment +} from './shared.js'; diff --git a/gitnexus/src/core/ingestion/type-extractors/jvm.ts b/gitnexus/src/core/ingestion/type-extractors/jvm.ts new file mode 100644 index 0000000000..2e55ff324a --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/jvm.ts @@ -0,0 +1,620 @@ +import type { SyntaxNode } from '../utils.js'; +import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, ForLoopExtractor, PendingAssignmentExtractor, PatternBindingExtractor } from './types.js'; +import { extractSimpleTypeName, extractVarName, findChildByType, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, type TypeArgPosition } from './shared.js'; + +// ── Java ────────────────────────────────────────────────────────────────── + +const JAVA_DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'local_variable_declaration', + 'field_declaration', +]); + +/** Java: Type x = ...; Type x; */ +const extractJavaDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + const typeNode = node.childForFieldName('type'); + if (!typeNode) return; + const typeName = extractSimpleTypeName(typeNode); + if (!typeName || typeName === 'var') return; // skip Java 10 var — handled by extractInitializer + + // Find variable_declarator children + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type !== 'variable_declarator') continue; + const nameNode = child.childForFieldName('name'); + if (nameNode) { + const varName = extractVarName(nameNode); + if (varName) env.set(varName, typeName); + } + } +}; + +/** Java 10+: var x = new User() — infer type from object_creation_expression */ +const extractJavaInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, _classNames: ClassNameLookup): void => { + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type !== 'variable_declarator') continue; + const nameNode = child.childForFieldName('name'); + const valueNode = child.childForFieldName('value'); + if (!nameNode || !valueNode) continue; + // Skip declarators that already have a binding from extractDeclaration + const varName = extractVarName(nameNode); + if (!varName || env.has(varName)) continue; + if (valueNode.type !== 'object_creation_expression') continue; + const ctorType = valueNode.childForFieldName('type'); + if (!ctorType) continue; + const typeName = extractSimpleTypeName(ctorType); + if (typeName) env.set(varName, typeName); + } +}; + +/** Java: formal_parameter → type name */ +const extractJavaParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'formal_parameter') { + typeNode = node.childForFieldName('type'); + nameNode = node.childForFieldName('name'); + } else { + // Generic fallback + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Java: var x = SomeFactory.create() — constructor binding for `var` with method_invocation */ +const scanJavaConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'local_variable_declaration') return undefined; + const typeNode = node.childForFieldName('type'); + if (!typeNode) return undefined; + if (typeNode.text !== 'var') return undefined; + const declarator = findChildByType(node, 'variable_declarator'); + if (!declarator) return undefined; + const nameNode = declarator.childForFieldName('name'); + const value = declarator.childForFieldName('value'); + if (!nameNode || !value) return undefined; + if (value.type === 'object_creation_expression') return undefined; + if (value.type !== 'method_invocation') return undefined; + const methodName = value.childForFieldName('name'); + if (!methodName) return undefined; + return { varName: nameNode.text, calleeName: methodName.text }; +}; + +const JAVA_FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set([ + 'enhanced_for_statement', +]); + +/** Extract element type from a Java type annotation AST node. + * Handles generic_type (List<User>), array_type (User[]). */ +const extractJavaElementTypeFromTypeNode = (typeNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + if (typeNode.type === 'generic_type') { + const args = extractGenericTypeArgs(typeNode); + if (args.length >= 1) return pos === 'first' ? args[0] : args[args.length - 1]; + } + if (typeNode.type === 'array_type') { + const elemNode = typeNode.firstNamedChild; + if (elemNode) return extractSimpleTypeName(elemNode); + } + return undefined; +}; + +/** Walk up from a for-each to the enclosing method_declaration and search parameters. */ +const findJavaParamElementType = (iterableName: string, startNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (current.type === 'method_declaration' || current.type === 'constructor_declaration') { + const paramsNode = current.childForFieldName('parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const param = paramsNode.namedChild(i); + if (!param || param.type !== 'formal_parameter') continue; + const nameNode = param.childForFieldName('name'); + if (nameNode?.text !== iterableName) continue; + const typeNode = param.childForFieldName('type'); + if (typeNode) return extractJavaElementTypeFromTypeNode(typeNode, pos); + } + } + break; + } + current = current.parent; + } + return undefined; +}; + +/** Java: for (User user : users) — extract loop variable binding. + * Tier 1c: for `for (var user : users)`, resolves element type from iterable. */ +const extractJavaForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }): void => { + const typeNode = node.childForFieldName('type'); + const nameNode = node.childForFieldName('name'); + if (!typeNode || !nameNode) return; + const varName = extractVarName(nameNode); + if (!varName) return; + + // Explicit type (existing behavior): for (User user : users) + const typeName = extractSimpleTypeName(typeNode); + if (typeName && typeName !== 'var') { + scopeEnv.set(varName, typeName); + return; + } + + // Tier 1c: var — resolve from iterable's container type + const iterableNode = node.childForFieldName('value'); + if (!iterableNode) return; + + let iterableName: string | undefined; + let methodName: string | undefined; + let callExprElementType: string | undefined; + if (iterableNode.type === 'identifier') { + iterableName = iterableNode.text; + } else if (iterableNode.type === 'field_access') { + const field = iterableNode.childForFieldName('field'); + if (field) iterableName = field.text; + } else if (iterableNode.type === 'method_invocation') { + // data.keySet() → method_invocation > object: identifier + name: identifier + // Also handles this.data.values() → object is field_access, extract inner field name + const obj = iterableNode.childForFieldName('object'); + const name = iterableNode.childForFieldName('name'); + if (obj?.type === 'identifier') { + iterableName = obj.text; + } else if (obj?.type === 'field_access') { + const innerField = obj.childForFieldName('field'); + if (innerField) iterableName = innerField.text; + } else if (!obj && name) { + // Direct function call: for (var u : getUsers()) — no receiver object + const rawReturn = returnTypeLookup.lookupRawReturnType(name.text); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + if (name) methodName = name.text; + } + if (!iterableName && !callExprElementType) return; + + let elementType: string | undefined; + if (callExprElementType) { + elementType = callExprElementType; + } else { + const containerTypeName = scopeEnv.get(iterableName!); + const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName); + elementType = resolveIterableElementType( + iterableName!, node, scopeEnv, declarationTypeNodes, scope, + extractJavaElementTypeFromTypeNode, findJavaParamElementType, + typeArgPos, + ); + } + if (elementType) scopeEnv.set(varName, elementType); +}; + +/** Java: var alias = u → local_variable_declaration > variable_declarator with name/value */ +const extractJavaPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (!child || child.type !== 'variable_declarator') continue; + const nameNode = child.childForFieldName('name'); + const valueNode = child.childForFieldName('value'); + if (!nameNode || !valueNode) continue; + const lhs = nameNode.text; + if (scopeEnv.has(lhs)) continue; + if (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier') return { kind: 'copy', lhs, rhs: valueNode.text }; + } + return undefined; +}; + +/** + * Java 16+ `instanceof` pattern variable: `x instanceof User user` + * + * AST structure: + * instanceof_expression + * left: expression (the variable being tested) + * instanceof keyword + * right: type (the type to test against) + * name: identifier (the pattern variable — optional, Java 16+) + * + * Conservative: returns undefined when the `name` field is absent (plain instanceof + * without pattern variable, e.g. `x instanceof User`) or when the type cannot be + * extracted. The source variable's existing type is NOT used — the pattern explicitly + * declares the new type, so no scopeEnv lookup is needed. + */ +const extractJavaPatternBinding: PatternBindingExtractor = (node) => { + if (node.type === 'type_pattern') { + // Java 17+ switch pattern: case User u -> ... + // type_pattern has positional children (NO named fields): + // namedChild(0) = type (type_identifier, e.g., User) + // namedChild(1) = identifier (e.g., u) + const typeNode = node.namedChild(0); + const nameNode = node.namedChild(1); + if (!typeNode || !nameNode) return undefined; + const typeName = extractSimpleTypeName(typeNode); + const varName = extractVarName(nameNode); + if (!typeName || !varName) return undefined; + return { varName, typeName }; + } + if (node.type !== 'instanceof_expression') return undefined; + const nameNode = node.childForFieldName('name'); + if (!nameNode) return undefined; + const typeNode = node.childForFieldName('right'); + if (!typeNode) return undefined; + const typeName = extractSimpleTypeName(typeNode); + const varName = extractVarName(nameNode); + if (!typeName || !varName) return undefined; + return { varName, typeName }; +}; + +export const javaTypeConfig: LanguageTypeConfig = { + declarationNodeTypes: JAVA_DECLARATION_NODE_TYPES, + forLoopNodeTypes: JAVA_FOR_LOOP_NODE_TYPES, + patternBindingNodeTypes: new Set(['instanceof_expression', 'type_pattern']), + extractDeclaration: extractJavaDeclaration, + extractParameter: extractJavaParameter, + extractInitializer: extractJavaInitializer, + scanConstructorBinding: scanJavaConstructorBinding, + extractForLoopBinding: extractJavaForLoopBinding, + extractPendingAssignment: extractJavaPendingAssignment, + extractPatternBinding: extractJavaPatternBinding, +}; + +// ── Kotlin ──────────────────────────────────────────────────────────────── + +const KOTLIN_DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'property_declaration', + 'variable_declaration', +]); + +/** Kotlin: val x: Foo = ... */ +const extractKotlinDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + if (node.type === 'property_declaration') { + // Kotlin property_declaration: name/type are inside a variable_declaration child + const varDecl = findChildByType(node, 'variable_declaration'); + if (varDecl) { + const nameNode = findChildByType(varDecl, 'simple_identifier'); + const typeNode = findChildByType(varDecl, 'user_type'); + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); + return; + } + // Fallback: try direct fields + const nameNode = node.childForFieldName('name') + ?? findChildByType(node, 'simple_identifier'); + const typeNode = node.childForFieldName('type') + ?? findChildByType(node, 'user_type'); + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); + } else if (node.type === 'variable_declaration') { + // variable_declaration directly inside functions + const nameNode = findChildByType(node, 'simple_identifier'); + const typeNode = findChildByType(node, 'user_type'); + if (nameNode && typeNode) { + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); + } + } +}; + +/** Kotlin: parameter / formal_parameter → type name. + * Kotlin's tree-sitter grammar uses positional children (simple_identifier, user_type) + * rather than named fields (name, type) on `parameter` nodes, so we fall back to + * findChildByType when childForFieldName returns null. */ +const extractKotlinParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'formal_parameter') { + typeNode = node.childForFieldName('type'); + nameNode = node.childForFieldName('name'); + } else { + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + // Fallback: Kotlin `parameter` nodes use positional children, not named fields + if (!nameNode) nameNode = findChildByType(node, 'simple_identifier'); + if (!typeNode) typeNode = findChildByType(node, 'user_type'); + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Kotlin: val user = User() — infer type from call_expression when callee is a known class. + * Kotlin constructors are syntactically identical to function calls, so we verify + * against classNames (which may include cross-file SymbolTable lookups). */ +const extractKotlinInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup): void => { + if (node.type !== 'property_declaration') return; + // Skip if there's an explicit type annotation — Tier 0 already handled it + const varDecl = findChildByType(node, 'variable_declaration'); + if (varDecl && findChildByType(varDecl, 'user_type')) return; + + // Get the initializer value — the call_expression after '=' + const value = node.childForFieldName('value') + ?? findChildByType(node, 'call_expression'); + if (!value || value.type !== 'call_expression') return; + + // The callee is the first child of call_expression (simple_identifier for direct calls) + const callee = value.firstNamedChild; + if (!callee || callee.type !== 'simple_identifier') return; + + const calleeName = callee.text; + if (!calleeName || !classNames.has(calleeName)) return; + + // Extract the variable name from the variable_declaration inside property_declaration + const nameNode = varDecl + ? findChildByType(varDecl, 'simple_identifier') + : findChildByType(node, 'simple_identifier'); + if (!nameNode) return; + + const varName = extractVarName(nameNode); + if (varName) env.set(varName, calleeName); +}; + +/** Kotlin: val x = User(...) — constructor binding for property_declaration with call_expression */ +const scanKotlinConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'property_declaration') return undefined; + const varDecl = findChildByType(node, 'variable_declaration'); + if (!varDecl) return undefined; + if (findChildByType(varDecl, 'user_type')) return undefined; + const callExpr = findChildByType(node, 'call_expression'); + if (!callExpr) return undefined; + const callee = callExpr.firstNamedChild; + if (!callee) return undefined; + + let calleeName: string | undefined; + if (callee.type === 'simple_identifier') { + calleeName = callee.text; + } else if (callee.type === 'navigation_expression') { + // Extract method name from qualified call: service.getUser() → getUser + const suffix = callee.lastNamedChild; + if (suffix?.type === 'navigation_suffix') { + const methodName = suffix.lastNamedChild; + if (methodName?.type === 'simple_identifier') { + calleeName = methodName.text; + } + } + } + if (!calleeName) return undefined; + const nameNode = findChildByType(varDecl, 'simple_identifier'); + if (!nameNode) return undefined; + return { varName: nameNode.text, calleeName }; +}; + +const KOTLIN_FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set([ + 'for_statement', +]); + +/** Extract element type from a Kotlin type annotation AST node (user_type wrapping generic). + * Kotlin: user_type → [type_identifier, type_arguments → [type_projection → user_type]] + * Handles the type_projection wrapper that Kotlin uses for generic type arguments. */ +const extractKotlinElementTypeFromTypeNode = (typeNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + if (typeNode.type === 'user_type') { + const argsNode = findChildByType(typeNode, 'type_arguments'); + if (argsNode && argsNode.namedChildCount >= 1) { + const targetArg = pos === 'first' + ? argsNode.namedChild(0) + : argsNode.namedChild(argsNode.namedChildCount - 1); + if (!targetArg) return undefined; + // Kotlin wraps type args in type_projection — unwrap to get the inner type + const inner = targetArg.type === 'type_projection' + ? targetArg.firstNamedChild + : targetArg; + if (inner) return extractSimpleTypeName(inner); + } + } + return undefined; +}; + +/** Walk up from a for-loop to the enclosing function_declaration and search parameters. + * Kotlin parameters use positional children (simple_identifier, user_type), not named fields. */ +const findKotlinParamElementType = (iterableName: string, startNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (current.type === 'function_declaration') { + const paramsNode = findChildByType(current, 'function_value_parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const param = paramsNode.namedChild(i); + if (!param || param.type !== 'parameter') continue; + const nameNode = findChildByType(param, 'simple_identifier'); + if (nameNode?.text !== iterableName) continue; + const typeNode = findChildByType(param, 'user_type'); + if (typeNode) return extractKotlinElementTypeFromTypeNode(typeNode, pos); + } + } + break; + } + current = current.parent; + } + return undefined; +}; + +/** Kotlin: for (user: User in users) — extract loop variable binding. + * Tier 1c: for `for (user in users)` without annotation, resolves from iterable. */ +const extractKotlinForLoopBinding: ForLoopExtractor = (node, ctx): void => { + const { scopeEnv, declarationTypeNodes, scope, returnTypeLookup } = ctx; + const varDecl = findChildByType(node, 'variable_declaration'); + if (!varDecl) return; + const nameNode = findChildByType(varDecl, 'simple_identifier'); + if (!nameNode) return; + const varName = extractVarName(nameNode); + if (!varName) return; + + // Explicit type annotation (existing behavior): for (user: User in users) + const typeNode = findChildByType(varDecl, 'user_type'); + if (typeNode) { + const typeName = extractSimpleTypeName(typeNode); + if (typeName) scopeEnv.set(varName, typeName); + return; + } + + // Tier 1c: no annotation — resolve from iterable's container type + // Kotlin for-loop children: [variable_declaration, iterable_expr, control_structure_body] + // The iterable is the second named child of the for_statement (after variable_declaration) + let iterableName: string | undefined; + let methodName: string | undefined; + let fallbackIterableName: string | undefined; + let callExprElementType: string | undefined; + let foundVarDecl = false; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child === varDecl) { foundVarDecl = true; continue; } + if (!foundVarDecl || !child) continue; + if (child.type === 'simple_identifier') { + iterableName = child.text; + break; + } + if (child.type === 'navigation_expression') { + // data.keys → navigation_expression > simple_identifier(data) + navigation_suffix > simple_identifier(keys) + const obj = child.firstNamedChild; + const suffix = findChildByType(child, 'navigation_suffix'); + const prop = suffix ? findChildByType(suffix, 'simple_identifier') : null; + const hasCallSuffix = suffix ? findChildByType(suffix, 'call_suffix') !== null : false; + // Always try object as iterable + property as method first (handles data.values, data.keys). + // For bare property access without call_suffix, also save property as fallback + // (handles this.users, repo.items where the property IS the iterable). + if (obj?.type === 'simple_identifier') iterableName = obj.text; + if (prop) methodName = prop.text; + if (!hasCallSuffix && prop) { + fallbackIterableName = prop.text; + } + break; + } + if (child.type === 'call_expression') { + // data.values() → call_expression > navigation_expression > simple_identifier + navigation_suffix + const callee = child.firstNamedChild; + if (callee?.type === 'navigation_expression') { + const obj = callee.firstNamedChild; + if (obj?.type === 'simple_identifier') iterableName = obj.text; + const suffix = findChildByType(callee, 'navigation_suffix'); + if (suffix) { + const prop = findChildByType(suffix, 'simple_identifier'); + if (prop) methodName = prop.text; + } + } else if (callee?.type === 'simple_identifier') { + // Direct function call: for (u in getUsers()) + const rawReturn = returnTypeLookup.lookupRawReturnType(callee.text); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + break; + } + } + if (!iterableName && !callExprElementType) return; + + let elementType: string | undefined; + if (callExprElementType) { + elementType = callExprElementType; + } else { + let containerTypeName = scopeEnv.get(iterableName!); + // Fallback: if object has no type in scope, try the property as the iterable name. + // Handles patterns like this.users where the property itself is the iterable variable. + if (!containerTypeName && fallbackIterableName) { + iterableName = fallbackIterableName; + methodName = undefined; + containerTypeName = scopeEnv.get(iterableName); + } + const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName); + elementType = resolveIterableElementType( + iterableName!, node, scopeEnv, declarationTypeNodes, scope, + extractKotlinElementTypeFromTypeNode, findKotlinParamElementType, + typeArgPos, + ); + } + if (elementType) scopeEnv.set(varName, elementType); +}; + +/** Kotlin: val alias = u → property_declaration or variable_declaration. + * property_declaration has: binding_pattern_kind("val"), variable_declaration("alias"), + * "=", and the RHS value (simple_identifier "u"). + * variable_declaration appears directly inside functions and has simple_identifier children. */ +const extractKotlinPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + if (node.type === 'property_declaration') { + // Find the variable name from variable_declaration child + const varDecl = findChildByType(node, 'variable_declaration'); + if (!varDecl) return undefined; + const nameNode = varDecl.firstNamedChild; + if (!nameNode || nameNode.type !== 'simple_identifier') return undefined; + const lhs = nameNode.text; + if (scopeEnv.has(lhs)) return undefined; + // Find the RHS: a simple_identifier sibling after the "=" token + let foundEq = false; + for (let i = 0; i < node.childCount; i++) { + const child = node.child(i); + if (!child) continue; + if (child.type === '=') { foundEq = true; continue; } + if (foundEq && child.type === 'simple_identifier') { + return { kind: 'copy', lhs, rhs: child.text }; + } + } + return undefined; + } + + if (node.type === 'variable_declaration') { + // variable_declaration directly inside functions: simple_identifier children + const nameNode = findChildByType(node, 'simple_identifier'); + if (!nameNode) return undefined; + const lhs = nameNode.text; + if (scopeEnv.has(lhs)) return undefined; + // Look for RHS simple_identifier after "=" in the parent (property_declaration) + // variable_declaration itself doesn't contain "=" — it's in the parent + const parent = node.parent; + if (!parent) return undefined; + let foundEq = false; + for (let i = 0; i < parent.childCount; i++) { + const child = parent.child(i); + if (!child) continue; + if (child.type === '=') { foundEq = true; continue; } + if (foundEq && child.type === 'simple_identifier') { + return { kind: 'copy', lhs, rhs: child.text }; + } + } + return undefined; + } + + return undefined; +}; + +/** Walk up from a node to find an ancestor of a given type. */ +const findAncestorByType = (node: SyntaxNode, type: string): SyntaxNode | undefined => { + let current = node.parent; + while (current) { + if (current.type === type) return current; + current = current.parent; + } + return undefined; +}; + +const extractKotlinPatternBinding: PatternBindingExtractor = (node) => { + if (node.type !== 'type_test') return undefined; + const typeNode = node.lastNamedChild; + if (!typeNode) return undefined; + const typeName = extractSimpleTypeName(typeNode); + if (!typeName) return undefined; + const whenExpr = findAncestorByType(node, 'when_expression'); + if (!whenExpr) return undefined; + const whenSubject = whenExpr.namedChild(0); + const subject = whenSubject?.firstNamedChild ?? whenSubject; + if (!subject) return undefined; + const varName = extractVarName(subject); + if (!varName) return undefined; + return { varName, typeName }; +}; + +export const kotlinTypeConfig: LanguageTypeConfig = { + allowPatternBindingOverwrite: true, + declarationNodeTypes: KOTLIN_DECLARATION_NODE_TYPES, + forLoopNodeTypes: KOTLIN_FOR_LOOP_NODE_TYPES, + patternBindingNodeTypes: new Set(['type_test']), + extractDeclaration: extractKotlinDeclaration, + extractParameter: extractKotlinParameter, + extractInitializer: extractKotlinInitializer, + scanConstructorBinding: scanKotlinConstructorBinding, + extractForLoopBinding: extractKotlinForLoopBinding, + extractPendingAssignment: extractKotlinPendingAssignment, + extractPatternBinding: extractKotlinPatternBinding, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/php.ts b/gitnexus/src/core/ingestion/type-extractors/php.ts new file mode 100644 index 0000000000..b140b1bb6c --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/php.ts @@ -0,0 +1,527 @@ +import type { SyntaxNode } from '../utils.js'; +import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, ReturnTypeExtractor, PendingAssignmentExtractor, ForLoopExtractor } from './types.js'; +import { extractSimpleTypeName, extractVarName, extractCalleeName, resolveIterableElementType, extractElementTypeFromString } from './shared.js'; + +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'assignment_expression', // For constructor inference: $x = new User() + 'property_declaration', // PHP 7.4+ typed properties: private UserRepo $repo; + 'method_declaration', // PHPDoc @param on class methods + 'function_definition', // PHPDoc @param on top-level functions +]); + +/** Walk up the AST to find the enclosing class declaration. */ +const findEnclosingClass = (node: SyntaxNode): SyntaxNode | null => { + let current = node.parent; + while (current) { + if (current.type === 'class_declaration') return current; + current = current.parent; + } + return null; +}; + +/** + * Resolve PHP self/static/parent to the actual class name. + * - self/static → enclosing class name + * - parent → superclass from base_clause + */ +const resolvePhpKeyword = (keyword: string, node: SyntaxNode): string | undefined => { + if (keyword === 'self' || keyword === 'static') { + const cls = findEnclosingClass(node); + if (!cls) return undefined; + const nameNode = cls.childForFieldName('name'); + return nameNode?.text; + } + if (keyword === 'parent') { + const cls = findEnclosingClass(node); + if (!cls) return undefined; + // base_clause contains the parent class name + for (let i = 0; i < cls.namedChildCount; i++) { + const child = cls.namedChild(i); + if (child?.type === 'base_clause') { + const parentName = child.firstNamedChild; + if (parentName) return extractSimpleTypeName(parentName); + } + } + return undefined; + } + return undefined; +}; + +const normalizePhpType = (raw: string): string | undefined => { + // Strip nullable prefix: ?User → User + let type = raw.startsWith('?') ? raw.slice(1) : raw; + // Strip array suffix: User[] → User + type = type.replace(/\[\]$/, ''); + // Strip union with null/false/void: User|null → User + const parts = type.split('|').filter(p => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed'); + if (parts.length !== 1) return undefined; + type = parts[0]; + // Strip namespace: \App\Models\User → User + const segments = type.split('\\'); + type = segments[segments.length - 1]; + // Skip uninformative types + if (type === 'mixed' || type === 'void' || type === 'self' || type === 'static' || type === 'object') return undefined; + // Extract element type from generic: Collection<User> → User + // PHPDoc generics encode the element type in angle brackets. Since PHP's Strategy B + // uses the scopeEnv value directly as the element type, we must store the inner type, + // not the container name. This mirrors how User[] → User is handled by the [] strip above. + const genericMatch = type.match(/^(\w+)\s*</); + if (genericMatch) { + const elementType = extractElementTypeFromString(type); + return elementType ?? undefined; + } + if (/^\w+$/.test(type)) return type; + return undefined; +}; + +/** Node types to skip when walking backwards to find doc-comments. + * PHP 8+ attributes (#[Route(...)]) appear as named siblings between PHPDoc and method. */ +const SKIP_NODE_TYPES: ReadonlySet<string> = new Set(['attribute_list', 'attribute']); + +/** Regex to extract PHPDoc @param annotations: `@param Type $name` (standard order) */ +const PHPDOC_PARAM_RE = /@param\s+(\S+)\s+\$(\w+)/g; +/** Alternate PHPDoc order: `@param $name Type` (name first) */ +const PHPDOC_PARAM_ALT_RE = /@param\s+\$(\w+)\s+(\S+)/g; +/** Regex to extract PHPDoc @var annotations: `@var Type` */ +const PHPDOC_VAR_RE = /@var\s+(\S+)/; + +/** + * Extract the element type for a class property from its PHPDoc @var annotation or + * PHP 7.4+ native type. Walks backward from the property_declaration node to find + * an immediately preceding comment containing @var. + * + * Returns the normalized element type (e.g. User[] → User, Collection<User> → User). + * Returns undefined when no usable type annotation is found. + */ +const extractClassPropertyElementType = (propDecl: SyntaxNode): string | undefined => { + // Strategy 1: PHPDoc @var annotation on a preceding comment sibling + let sibling = propDecl.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + const match = PHPDOC_VAR_RE.exec(sibling.text); + if (match) return normalizePhpType(match[1]); + } else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type)) { + break; + } + sibling = sibling.previousSibling; + } + // Strategy 2: PHP 7.4+ native type field — skip generic 'array' since element type is unknown + const typeNode = propDecl.childForFieldName('type'); + if (!typeNode) return undefined; + const typeName = extractSimpleTypeName(typeNode); + if (!typeName || typeName === 'array') return undefined; + return typeName; +}; + +/** + * Scan a class body for a property_declaration matching the given property name, + * and extract its element type. The class body is the `declaration_list` child of + * a `class_declaration` node. + * + * Used as Strategy C in extractForLoopBinding for `$this->property` iterables + * where Strategy A (resolveIterableElementType) and Strategy B (scopeEnv lookup) + * both fail to find the type. + */ +const findClassPropertyElementType = (propName: string, classNode: SyntaxNode): string | undefined => { + const declList = classNode.childForFieldName('body') + ?? (classNode.namedChild(classNode.namedChildCount - 1)?.type === 'declaration_list' + ? classNode.namedChild(classNode.namedChildCount - 1) + : null); // fallback: last named child, only if it's a declaration_list + if (!declList) return undefined; + for (let i = 0; i < declList.namedChildCount; i++) { + const child = declList.namedChild(i); + if (child?.type !== 'property_declaration') continue; + // Check if any property_element has a variable_name matching '$propName' + for (let j = 0; j < child.namedChildCount; j++) { + const elem = child.namedChild(j); + if (elem?.type !== 'property_element') continue; + const varNameNode = elem.firstNamedChild; // variable_name node + if (varNameNode?.text === '$' + propName) { + return extractClassPropertyElementType(child); + } + } + } + return undefined; +}; + +/** + * Collect PHPDoc @param type bindings from comment nodes preceding a method/function. + * Returns a map of paramName → typeName (without $ prefix). + */ +const collectPhpDocParams = (methodNode: SyntaxNode): Map<string, string> => { + const commentTexts: string[] = []; + let sibling = methodNode.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + commentTexts.unshift(sibling.text); + } else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type)) { + break; + } + sibling = sibling.previousSibling; + } + if (commentTexts.length === 0) return new Map(); + + const params = new Map<string, string>(); + const commentBlock = commentTexts.join('\n'); + PHPDOC_PARAM_RE.lastIndex = 0; + let match: RegExpExecArray | null; + while ((match = PHPDOC_PARAM_RE.exec(commentBlock)) !== null) { + const typeName = normalizePhpType(match[1]); + const paramName = match[2]; // without $ prefix + if (typeName) { + // Store with $ prefix to match how PHP variables appear in the env + params.set('$' + paramName, typeName); + } + } + + // Also check alternate PHPDoc order: @param $name Type + PHPDOC_PARAM_ALT_RE.lastIndex = 0; + while ((match = PHPDOC_PARAM_ALT_RE.exec(commentBlock)) !== null) { + const paramName = match[1]; + if (params.has('$' + paramName)) continue; // standard format takes priority + const typeName = normalizePhpType(match[2]); + if (typeName) { + params.set('$' + paramName, typeName); + } + } + return params; +}; + +/** + * PHP: typed class properties (PHP 7.4+): private UserRepo $repo; + * Also: PHPDoc @param annotations on method/function definitions. + */ +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + // PHPDoc @param on methods/functions — pre-populate env with param types + if (node.type === 'method_declaration' || node.type === 'function_definition') { + const phpDocParams = collectPhpDocParams(node); + for (const [paramName, typeName] of phpDocParams) { + if (!env.has(paramName)) env.set(paramName, typeName); + } + return; + } + + if (node.type !== 'property_declaration') return; + + const typeNode = node.childForFieldName('type'); + if (!typeNode) return; + + const typeName = extractSimpleTypeName(typeNode); + if (!typeName) return; + + // The variable name is inside property_element > variable_name + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === 'property_element') { + const varNameNode = child.firstNamedChild; // variable_name + if (varNameNode) { + const varName = extractVarName(varNameNode); + if (varName) env.set(varName, typeName); + } + break; + } + } +}; + +/** PHP: $x = new User() — infer type from object_creation_expression */ +const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, _classNames: ClassNameLookup): void => { + if (node.type !== 'assignment_expression') return; + const left = node.childForFieldName('left'); + const right = node.childForFieldName('right'); + if (!left || !right) return; + if (right.type !== 'object_creation_expression') return; + // The class name is the first named child of object_creation_expression + // (tree-sitter-php uses 'name' or 'qualified_name' nodes here) + const ctorType = right.firstNamedChild; + if (!ctorType) return; + const typeName = extractSimpleTypeName(ctorType); + if (!typeName) return; + // Resolve PHP self/static/parent to actual class names + const resolvedType = (typeName === 'self' || typeName === 'static' || typeName === 'parent') + ? resolvePhpKeyword(typeName, node) + : typeName; + if (!resolvedType) return; + const varName = extractVarName(left); + if (varName) env.set(varName, resolvedType); +}; + +/** PHP: simple_parameter → type $name */ +const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'simple_parameter') { + typeNode = node.childForFieldName('type'); + nameNode = node.childForFieldName('name'); + } else { + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + if (!varName) return; + // Don't overwrite PHPDoc-derived types (e.g. @param User[] $users → User) + // with the less-specific AST type annotation (e.g. array). + if (env.has(varName)) return; + const typeName = extractSimpleTypeName(typeNode); + if (typeName) env.set(varName, typeName); +}; + +/** PHP: $x = SomeFactory() or $x = $this->getUser() — bind variable to call return type */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'assignment_expression') return undefined; + const left = node.childForFieldName('left'); + const right = node.childForFieldName('right'); + if (!left || !right) return undefined; + if (left.type !== 'variable_name') return undefined; + // Skip object_creation_expression (new User()) — handled by extractInitializer + if (right.type === 'object_creation_expression') return undefined; + // Handle both standalone function calls and method calls ($this->getUser()) + if (right.type === 'function_call_expression') { + const calleeName = extractCalleeName(right); + if (!calleeName) return undefined; + return { varName: left.text, calleeName }; + } + if (right.type === 'member_call_expression') { + const methodName = right.childForFieldName('name'); + if (!methodName) return undefined; + // When receiver is $this/self/static, qualify with enclosing class for disambiguation + const receiver = right.childForFieldName('object'); + const receiverText = receiver?.text; + let receiverClassName: string | undefined; + if (receiverText === '$this' || receiverText === 'self' || receiverText === 'static') { + const cls = findEnclosingClass(node); + const clsName = cls?.childForFieldName('name'); + if (clsName) receiverClassName = clsName.text; + } + return { varName: left.text, calleeName: methodName.text, receiverClassName }; + } + return undefined; +}; + +/** Regex to extract PHPDoc @return annotations: `@return User` */ +const PHPDOC_RETURN_RE = /@return\s+(\S+)/; + +/** + * Normalize a PHPDoc return type for storage in the SymbolTable. + * Unlike normalizePhpType (which strips User[] → User for scopeEnv), this preserves + * array notation so lookupRawReturnType can extract element types for for-loop resolution. + * \App\Models\User[] → User[] + * ?User → User + * Collection<User> → Collection<User> (preserved for extractElementTypeFromString) + */ +const normalizePhpReturnType = (raw: string): string | undefined => { + // Strip nullable prefix: ?User[] → User[] + let type = raw.startsWith('?') ? raw.slice(1) : raw; + // Strip union with null/false/void: User[]|null → User[] + const parts = type.split('|').filter(p => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed'); + if (parts.length !== 1) return undefined; + type = parts[0]; + // Strip namespace: \App\Models\User[] → User[] + const segments = type.split('\\'); + type = segments[segments.length - 1]; + // Skip uninformative types + if (type === 'mixed' || type === 'void' || type === 'self' || type === 'static' || type === 'object' || type === 'array') return undefined; + if (/^\w+(\[\])?$/.test(type) || /^\w+\s*</.test(type)) return type; + return undefined; +}; + +/** + * Extract return type from PHPDoc `@return Type` annotation preceding a method. + * Walks backwards through preceding siblings looking for comment nodes. + * Preserves array notation (e.g., User[]) for for-loop element type extraction. + */ +const extractReturnType: ReturnTypeExtractor = (node) => { + let sibling = node.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + const match = PHPDOC_RETURN_RE.exec(sibling.text); + if (match) return normalizePhpReturnType(match[1]); + } else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type)) break; + sibling = sibling.previousSibling; + } + return undefined; +}; + +/** PHP: $alias = $user → assignment_expression with variable_name left/right. + * PHP TypeEnv stores variables WITH $ prefix ($user → User), so we keep $ in lhs/rhs. */ +const extractPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + if (node.type !== 'assignment_expression') return undefined; + const left = node.childForFieldName('left'); + const right = node.childForFieldName('right'); + if (!left || !right) return undefined; + if (left.type !== 'variable_name' || right.type !== 'variable_name') return undefined; + const lhs = left.text; + const rhs = right.text; + if (!lhs || !rhs || scopeEnv.has(lhs)) return undefined; + return { kind: 'copy', lhs, rhs }; +}; + +const FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set([ + 'foreach_statement', +]); + +/** Extract element type from a PHP type annotation AST node. + * PHP has limited AST-level container types — `array` is a primitive_type with no generic args. + * Named types (e.g., `Collection`) are returned as-is (container descriptor lookup handles them). */ +const extractPhpElementTypeFromTypeNode = (_typeNode: SyntaxNode): string | undefined => { + // PHP AST type nodes don't carry generic parameters (array<User> is PHPDoc-only). + // primitive_type 'array' and named_type 'Collection' don't encode element types. + return undefined; +}; + +/** Walk up from a foreach to the enclosing function and search parameter type annotations. + * PHP parameter type hints are limited (array, ClassName) — this extracts element type when possible. */ +const findPhpParamElementType = (iterableName: string, startNode: SyntaxNode): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (current.type === 'method_declaration' || current.type === 'function_definition') { + const paramsNode = current.childForFieldName('parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const param = paramsNode.namedChild(i); + if (!param || param.type !== 'simple_parameter') continue; + const nameNode = param.childForFieldName('name'); + if (nameNode?.text !== iterableName) continue; + const typeNode = param.childForFieldName('type'); + if (typeNode) return extractPhpElementTypeFromTypeNode(typeNode); + } + } + break; + } + current = current.parent; + } + return undefined; +}; + +/** + * PHP: foreach ($users as $user) — extract loop variable binding. + * + * AST structure (from tree-sitter-php grammar): + * foreach_statement — no named fields for iterable/value (only 'body') + * children[0]: expression (iterable, e.g. $users) + * children[1]: expression (simple value) OR pair ($key => $value) + * pair children: expression (key), expression (value) + * + * PHP's PHPDoc @param normalizes `User[]` → `User` in the env, so the iterable's + * stored type IS the element type. We first try resolveIterableElementType (for + * constructor-binding cases that retain container types), then fall back to direct + * scopeEnv lookup (for PHPDoc-normalized types). + */ +const extractForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }): void => { + if (node.type !== 'foreach_statement') return; + + // Collect non-body named children: first is the iterable, second is value or pair + const children: SyntaxNode[] = []; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child && child !== node.childForFieldName('body')) { + children.push(child); + } + } + if (children.length < 2) return; + + const iterableNode = children[0]; + const valueOrPair = children[1]; + + // Determine the loop variable node + let loopVarNode: SyntaxNode; + if (valueOrPair.type === 'pair') { + // $key => $value — the value is the last named child of the pair + const lastChild = valueOrPair.namedChild(valueOrPair.namedChildCount - 1); + if (!lastChild) return; + // Handle by_ref: foreach ($arr as $k => &$v) + loopVarNode = lastChild.type === 'by_ref' ? (lastChild.firstNamedChild ?? lastChild) : lastChild; + } else { + // Simple: foreach ($users as $user) or foreach ($users as &$user) + loopVarNode = valueOrPair.type === 'by_ref' ? (valueOrPair.firstNamedChild ?? valueOrPair) : valueOrPair; + } + + const varName = extractVarName(loopVarNode); + if (!varName) return; + + // Get iterable variable name (PHP vars include $ prefix) + let iterableName: string | undefined; + let callExprElementType: string | undefined; + if (iterableNode.type === 'variable_name') { + iterableName = iterableNode.text; + } else if (iterableNode?.type === 'member_access_expression') { + const name = iterableNode.childForFieldName('name'); + // PHP properties are stored in scopeEnv with $ prefix ($users), but + // member_access_expression.name returns without $ (users). Add $ to match. + if (name) iterableName = '$' + name.text; + } else if (iterableNode?.type === 'function_call_expression') { + // foreach (getUsers() as $user) — resolve via return type lookup + const calleeName = extractCalleeName(iterableNode); + if (calleeName) { + const rawReturn = returnTypeLookup.lookupRawReturnType(calleeName); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + } else if (iterableNode?.type === 'member_call_expression') { + // foreach ($this->getUsers() as $user) — resolve via return type lookup + const methodName = iterableNode.childForFieldName('name'); + if (methodName) { + const rawReturn = returnTypeLookup.lookupRawReturnType(methodName.text); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + } + if (!iterableName && !callExprElementType) return; + + // If we resolved the element type from a call expression, bind and return early + if (callExprElementType) { + scopeEnv.set(varName, callExprElementType); + return; + } + + // Strategy A: try resolveIterableElementType (handles constructor-binding container types) + const elementType = resolveIterableElementType( + iterableName, node, scopeEnv, declarationTypeNodes, scope, + extractPhpElementTypeFromTypeNode, findPhpParamElementType, + undefined, + ); + if (elementType) { + scopeEnv.set(varName, elementType); + return; + } + + // Strategy B: direct scopeEnv lookup — PHP normalizePhpType strips User[] → User, + // so the iterable's stored type is already the element type from PHPDoc annotations. + const iterableType = scopeEnv.get(iterableName); + if (iterableType) { + scopeEnv.set(varName, iterableType); + return; + } + + // Strategy C: $this->property — scan the enclosing class body for the property + // declaration and extract its element type from @var PHPDoc or native type. + // This handles the common PHP pattern where the property type is declared on the + // class body (/** @var User[] */ private $users) but the foreach is in a method + // whose scopeEnv does not contain the property type. + if (iterableNode?.type === 'member_access_expression') { + const obj = iterableNode.childForFieldName('object'); + if (obj?.text === '$this') { + const nameNode = iterableNode.childForFieldName('name'); + const propName = nameNode?.text; + if (propName) { + const classNode = findEnclosingClass(iterableNode); + if (classNode) { + const elementType = findClassPropertyElementType(propName, classNode); + if (elementType) scopeEnv.set(varName, elementType); + } + } + } + } +}; + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + forLoopNodeTypes: FOR_LOOP_NODE_TYPES, + extractDeclaration, + extractParameter, + extractInitializer, + scanConstructorBinding, + extractReturnType, + extractForLoopBinding, + extractPendingAssignment, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/python.ts b/gitnexus/src/core/ingestion/type-extractors/python.ts new file mode 100644 index 0000000000..ca4192cff8 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/python.ts @@ -0,0 +1,437 @@ +import type { SyntaxNode } from '../utils.js'; +import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, PendingAssignmentExtractor, PatternBindingExtractor, ForLoopExtractor } from './types.js'; +import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, type TypeArgPosition } from './shared.js'; + +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'assignment', + 'named_expression', + 'expression_statement', +]); + +/** Python: x: Foo = ... (PEP 484 annotated assignment) or x: Foo (standalone annotation). + * + * tree-sitter-python grammar produces two distinct shapes: + * + * 1. Annotated assignment with value: `name: str = ""` + * Node type: `assignment` + * Fields: left=identifier, type=identifier/type, right=value + * + * 2. Standalone annotation (no value): `name: str` + * Node type: `expression_statement` + * Child: `type` node with fields name=identifier, type=identifier/type + * + * Both appear at file scope and inside class bodies (PEP 526 class variable annotations). + */ +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + if (node.type === 'expression_statement') { + // Standalone annotation: expression_statement > type { name: identifier, type: identifier } + const typeChild = node.firstNamedChild; + if (!typeChild || typeChild.type !== 'type') return; + const nameNode = typeChild.childForFieldName('name'); + const typeNode = typeChild.childForFieldName('type'); + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const inner = typeNode.type === 'type' ? (typeNode.firstNamedChild ?? typeNode) : typeNode; + const typeName = extractSimpleTypeName(inner) ?? inner.text; + if (varName && typeName) env.set(varName, typeName); + return; + } + + // Annotated assignment: left : type = value + const left = node.childForFieldName('left'); + const typeNode = node.childForFieldName('type'); + if (!left || !typeNode) return; + const varName = extractVarName(left); + // extractSimpleTypeName handles identifiers and qualified names. + // Python 3.10+ union syntax `User | None` is parsed as binary_operator, + // which extractSimpleTypeName doesn't handle. Fall back to raw text so + // stripNullable can process it at lookup time (e.g., "User | None" → "User"). + const inner = typeNode.type === 'type' ? (typeNode.firstNamedChild ?? typeNode) : typeNode; + const typeName = extractSimpleTypeName(inner) ?? inner.text; + if (varName && typeName) env.set(varName, typeName); +}; + +/** Python: parameter with type annotation */ +const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'parameter') { + nameNode = node.childForFieldName('name'); + typeNode = node.childForFieldName('type'); + } else { + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + // Python typed_parameter: name is a positional child (identifier), not a named field + if (!nameNode && node.type === 'typed_parameter') { + nameNode = node.firstNamedChild?.type === 'identifier' ? node.firstNamedChild : null; + } + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Python: user = User("alice") — infer type from call when callee is a known class. + * Python constructors are syntactically identical to function calls, so we verify + * against classNames (which may include cross-file SymbolTable lookups). + * Also handles walrus operator: if (user := User("alice")): */ +const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup): void => { + let left: SyntaxNode | null; + let right: SyntaxNode | null; + + if (node.type === 'named_expression') { + // Walrus operator: (user := User("alice")) + // tree-sitter-python: named_expression has 'name' and 'value' fields + left = node.childForFieldName('name'); + right = node.childForFieldName('value'); + } else if (node.type === 'assignment') { + left = node.childForFieldName('left'); + right = node.childForFieldName('right'); + // Skip if already has type annotation — extractDeclaration handled it + if (node.childForFieldName('type')) return; + } else { + return; + } + + if (!left || !right) return; + const varName = extractVarName(left); + if (!varName || env.has(varName)) return; + if (right.type !== 'call') return; + const func = right.childForFieldName('function'); + if (!func) return; + // Support both direct calls (User()) and qualified calls (models.User()) + // tree-sitter-python: direct → identifier, qualified → attribute + const calleeName = extractSimpleTypeName(func); + if (!calleeName) return; + if (classNames.has(calleeName)) { + env.set(varName, calleeName); + } +}; + +/** Python: user = User("alice") — scan assignment/walrus for constructor-like calls. + * Returns {varName, calleeName} without checking classNames (caller validates). */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + let left: SyntaxNode | null; + let right: SyntaxNode | null; + + if (node.type === 'named_expression') { + left = node.childForFieldName('name'); + right = node.childForFieldName('value'); + } else if (node.type === 'assignment') { + left = node.childForFieldName('left'); + right = node.childForFieldName('right'); + if (node.childForFieldName('type')) return undefined; + } else { + return undefined; + } + + if (!left || !right) return undefined; + if (left.type !== 'identifier') return undefined; + if (right.type !== 'call') return undefined; + const func = right.childForFieldName('function'); + if (!func) return undefined; + const calleeName = extractSimpleTypeName(func); + if (!calleeName) return undefined; + return { varName: left.text, calleeName }; +}; + +const FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set([ + 'for_statement', +]); + +/** Python function/method node types that carry a parameters list. */ +const PY_FUNCTION_NODE_TYPES = new Set([ + 'function_definition', 'decorated_definition', +]); + +/** + * Extract element type from a Python type annotation AST node. + * Handles: + * subscript "List[User]" → extractElementTypeFromString("List[User]") → "User" + * generic_type → extractGenericTypeArgs → first arg + * Falls back to text-based extraction. + */ +const extractPyElementTypeFromAnnotation = (typeNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + // Unwrap 'type' wrapper node to get to the actual type (e.g., type > generic_type) + const inner = typeNode.type === 'type' ? (typeNode.firstNamedChild ?? typeNode) : typeNode; + + // Python subscript: List[User], Sequence[User] — use raw text + if (inner.type === 'subscript') { + return extractElementTypeFromString(inner.text, pos); + } + // generic_type: dict[str, User] — tree-sitter-python uses type_parameter child + if (inner.type === 'generic_type') { + // Try standard extractGenericTypeArgs first (handles type_arguments) + const args = extractGenericTypeArgs(inner); + if (args.length >= 1) return pos === 'first' ? args[0] : args[args.length - 1]; + // Fallback: look for type_parameter child (tree-sitter-python specific) + for (let i = 0; i < inner.namedChildCount; i++) { + const child = inner.namedChild(i); + if (child?.type === 'type_parameter') { + if (pos === 'first') { + const firstArg = child.firstNamedChild; + if (firstArg) return extractSimpleTypeName(firstArg); + } else { + const lastArg = child.lastNamedChild; + if (lastArg) return extractSimpleTypeName(lastArg); + } + } + } + } + // Fallback: raw text extraction (handles User[], [User], etc.) + return extractElementTypeFromString(inner.text, pos); +}; + +/** + * Walk up the AST from a for-statement to find the enclosing function definition, + * then search its parameters for one named `iterableName`. + * Returns the element type extracted from its type annotation, or undefined. + * + * Handles both `parameter` and `typed_parameter` node types in tree-sitter-python. + * `typed_parameter` may not expose the name as a `name` field — falls back to + * checking the first identifier-type named child. + */ +const findPyParamElementType = (iterableName: string, startNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (current.type === 'function_definition') { + const paramsNode = current.childForFieldName('parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const param = paramsNode.namedChild(i); + if (!param) continue; + // Try named `name` field first (parameter node), then first identifier child + // (typed_parameter node may store name as first positional child) + const nameNode = param.childForFieldName('name') + ?? (param.firstNamedChild?.type === 'identifier' ? param.firstNamedChild : null); + if (nameNode?.text !== iterableName) continue; + // Try `type` field, then last named child (typed_parameter stores type last) + const typeAnnotation = param.childForFieldName('type') + ?? (param.namedChildCount >= 2 ? param.namedChild(param.namedChildCount - 1) : null); + if (typeAnnotation && typeAnnotation !== nameNode) { + return extractPyElementTypeFromAnnotation(typeAnnotation, pos); + } + } + } + break; + } + current = current.parent; + } + return undefined; +}; + +/** + * Extracts iterableName and methodName from a call expression like `data.items()`. + * Returns undefined if the call doesn't match the expected pattern. + */ +const extractMethodCall = (callNode: SyntaxNode): { iterableName: string; methodName?: string } | undefined => { + const fn = callNode.childForFieldName('function'); + if (fn?.type !== 'attribute') return undefined; + const obj = fn.firstNamedChild; + if (obj?.type !== 'identifier') return undefined; + const method = fn.lastNamedChild; + const methodName = (method?.type === 'identifier' && method !== obj) ? method.text : undefined; + return { iterableName: obj.text, methodName }; +}; + +/** + * Collects all identifier nodes from a pattern, descending into nested tuple_patterns. + * For `i, (k, v)` returns [i, k, v]. For `key, value` returns [key, value]. + */ +const collectPatternIdentifiers = (pattern: SyntaxNode): SyntaxNode[] => { + const vars: SyntaxNode[] = []; + for (let i = 0; i < pattern.namedChildCount; i++) { + const child = pattern.namedChild(i); + if (child?.type === 'identifier') { + vars.push(child); + } else if (child?.type === 'tuple_pattern') { + vars.push(...collectPatternIdentifiers(child)); + } + } + return vars; +}; + +/** + * Python: for user in users: where users has a known container type annotation. + * + * AST node: `for_statement` with `left` (loop variable) and `right` (iterable). + * + * Tier 1c: resolves the element type via three strategies in priority order: + * 1. declarationTypeNodes — raw type annotation AST node (covers stored container types) + * 2. scopeEnv string — extractElementTypeFromString on the stored type + * 3. AST walk — walks up to the enclosing function's parameters to read List[User] directly + * + * Also handles `enumerate(iterable)` — unwraps the outer call and skips the integer + * index variable so the value variable still resolves to the element type. + */ +const extractForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }): void => { + if (node.type !== 'for_statement') return; + + const rightNode = node.childForFieldName('right'); + let iterableName: string | undefined; + let methodName: string | undefined; + let callExprElementType: string | undefined; + let isEnumerate = false; + + // Extract iterable info from the `right` field — may be identifier, attribute, or call. + if (rightNode?.type === 'identifier') { + iterableName = rightNode.text; + } else if (rightNode?.type === 'attribute') { + const prop = rightNode.lastNamedChild; + if (prop) iterableName = prop.text; + } else if (rightNode?.type === 'call') { + const fn = rightNode.childForFieldName('function'); + if (fn?.type === 'identifier' && fn.text === 'enumerate') { + // enumerate(iterable) or enumerate(d.items()) — unwrap to inner iterable. + isEnumerate = true; + const innerArg = rightNode.childForFieldName('arguments')?.firstNamedChild; + if (innerArg?.type === 'identifier') { + iterableName = innerArg.text; + } else if (innerArg?.type === 'call') { + const extracted = extractMethodCall(innerArg); + if (extracted) ({ iterableName, methodName } = extracted); + } + } else if (fn?.type === 'attribute') { + // data.items() → call > function: attribute > identifier('data') + identifier('items') + const extracted = extractMethodCall(rightNode); + if (extracted) ({ iterableName, methodName } = extracted); + } else if (fn?.type === 'identifier') { + // Direct function call: for user in get_users() (Phase 7.3 — return-type path) + const rawReturn = returnTypeLookup.lookupRawReturnType(fn.text); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + } + if (!iterableName && !callExprElementType) return; + + let elementType: string | undefined; + if (callExprElementType) { + elementType = callExprElementType; + } else { + const containerTypeName = scopeEnv.get(iterableName!); + const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName); + elementType = resolveIterableElementType( + iterableName!, node, scopeEnv, declarationTypeNodes, scope, + extractPyElementTypeFromAnnotation, findPyParamElementType, + typeArgPos, + ); + } + if (!elementType) return; + + // The loop variable is the `left` field — identifier or pattern_list. + const leftNode = node.childForFieldName('left'); + if (!leftNode) return; + + if (leftNode.type === 'pattern_list' || leftNode.type === 'tuple_pattern') { + // Tuple unpacking: `key, value` or `i, (k, v)` or `(k, v)` — bind the last identifier to element type. + // With enumerate, skip binding if there's only one var (just the index, no value to bind). + const vars = collectPatternIdentifiers(leftNode); + if (vars.length > 0 && (!isEnumerate || vars.length > 1)) { + scopeEnv.set(vars[vars.length - 1].text, elementType); + } + return; + } + + const loopVarName = extractVarName(leftNode); + if (loopVarName) scopeEnv.set(loopVarName, elementType); +}; + +/** Python: alias = u → assignment with left/right fields. + * Also handles walrus operator: alias := u → named_expression with name/value fields. */ +const extractPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + let left: SyntaxNode | null; + let right: SyntaxNode | null; + + if (node.type === 'assignment') { + left = node.childForFieldName('left'); + right = node.childForFieldName('right'); + } else if (node.type === 'named_expression') { + left = node.childForFieldName('name'); + right = node.childForFieldName('value'); + } else { + return undefined; + } + + if (!left || !right) return undefined; + const lhs = left.type === 'identifier' ? left.text : undefined; + if (!lhs || scopeEnv.has(lhs)) return undefined; + if (right.type === 'identifier') return { kind: 'copy', lhs, rhs: right.text }; + return undefined; +}; + +/** + * Python match/case `as` pattern binding: `case User() as u:` + * + * AST structure (tree-sitter-python): + * as_pattern + * alias: as_pattern_target ← the bound variable name (e.g. "u") + * children[0]: case_pattern ← wraps class_pattern (or is class_pattern directly) + * class_pattern + * dotted_name ← the class name (e.g. "User") + * + * The `alias` field is an `as_pattern_target` node whose `.text` is the identifier. + * The class name lives in the first non-alias named child: either a `case_pattern` + * wrapping a `class_pattern`, or a direct `class_pattern`. + * + * Conservative: returns undefined when: + * - The node is not an `as_pattern` + * - The pattern side is not a class_pattern (e.g. guard or literal match) + * - The variable was already bound in scopeEnv + */ +const extractPatternBinding: PatternBindingExtractor = (node, scopeEnv) => { + if (node.type !== 'as_pattern') return undefined; + + // as_pattern: `case User() as u:` — binds matched value to a name. + // Try named field first (future grammar versions may expose it), fall back to positional. + if (node.namedChildCount < 2) return undefined; + + const patternChild = node.namedChild(0); + const varNameNode = node.childForFieldName('alias') + ?? node.namedChild(node.namedChildCount - 1); + if (!patternChild || !varNameNode) return undefined; + if (varNameNode.type !== 'identifier') return undefined; + + const varName = varNameNode.text; + if (!varName || scopeEnv.has(varName)) return undefined; + + // Find the class_pattern — may be direct or wrapped in case_pattern. + let classPattern: SyntaxNode | null = null; + if (patternChild.type === 'class_pattern') { + classPattern = patternChild; + } else if (patternChild.type === 'case_pattern') { + // Unwrap one level: case_pattern wraps class_pattern + for (let j = 0; j < patternChild.namedChildCount; j++) { + const inner = patternChild.namedChild(j); + if (inner?.type === 'class_pattern') { + classPattern = inner; + break; + } + } + } + if (!classPattern) return undefined; + + // class_pattern children: dotted_name (the class name) + optional keyword_pattern args. + const classNameNode = classPattern.firstNamedChild; + if (!classNameNode || (classNameNode.type !== 'dotted_name' && classNameNode.type !== 'identifier')) return undefined; + const typeName = classNameNode.text; + if (!typeName) return undefined; + + return { varName, typeName }; +}; + +const PATTERN_BINDING_NODE_TYPES: ReadonlySet<string> = new Set(['as_pattern']); + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + forLoopNodeTypes: FOR_LOOP_NODE_TYPES, + patternBindingNodeTypes: PATTERN_BINDING_NODE_TYPES, + extractDeclaration, + extractParameter, + extractInitializer, + scanConstructorBinding, + extractForLoopBinding, + extractPendingAssignment, + extractPatternBinding, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/ruby.ts b/gitnexus/src/core/ingestion/type-extractors/ruby.ts new file mode 100644 index 0000000000..953708be95 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/ruby.ts @@ -0,0 +1,406 @@ +import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, ReturnTypeExtractor, PendingAssignmentExtractor, ForLoopExtractor } from './types.js'; +import { extractRubyConstructorAssignment, extractSimpleTypeName, extractElementTypeFromString, extractVarName, resolveIterableElementType } from './shared.js'; +import type { SyntaxNode } from '../utils.js'; + +/** + * Ruby type extractor — YARD annotation parsing. + * + * Ruby has no static type system, but the YARD documentation convention + * provides de facto type annotations via comments: + * + * # @param name [String] the user's name + * # @param repo [UserRepo] the repository + * # @return [User] + * def create(name, repo) + * repo.save + * end + * + * This extractor parses `@param name [Type]` patterns from comment nodes + * preceding method definitions and binds parameter names to their types. + * + * Resolution tiers: + * - Tier 0: YARD @param annotations (extractDeclaration pre-populates env) + * - Tier 1: Constructor inference via `user = User.new` (handled by scanConstructorBinding in typeConfig) + */ + +/** Regex to extract @param annotations: `@param name [Type]` */ +const YARD_PARAM_RE = /@param\s+(\w+)\s+\[([^\]]+)\]/g; +/** Alternate YARD order: `@param [Type] name` */ +const YARD_PARAM_ALT_RE = /@param\s+\[([^\]]+)\]\s+(\w+)/g; + +/** Regex to extract @return annotations: `@return [Type]` */ +const YARD_RETURN_RE = /@return\s+\[([^\]]+)\]/; + +/** + * Extract the simple type name from a YARD type string. + * Handles: + * - Simple types: "String" → "String" + * - Qualified types: "Models::User" → "User" + * - Generic types: "Array<User>" → "Array" + * - Nullable types: "String, nil" → "String" + * - Union types: "String, Integer" → undefined (ambiguous) + */ +const extractYardTypeName = (yardType: string): string | undefined => { + const trimmed = yardType.trim(); + + // Handle nullable: "Type, nil" or "nil, Type" + // Use bracket-balanced split to avoid breaking on commas inside generics like Hash<Symbol, User> + const parts: string[] = []; + let depth = 0, start = 0; + for (let i = 0; i < trimmed.length; i++) { + if (trimmed[i] === '<') depth++; + else if (trimmed[i] === '>') depth--; + else if (trimmed[i] === ',' && depth === 0) { + parts.push(trimmed.slice(start, i).trim()); + start = i + 1; + } + } + parts.push(trimmed.slice(start).trim()); + const filtered = parts.filter(p => p !== '' && p !== 'nil'); + if (filtered.length !== 1) return undefined; // ambiguous union + + const typePart = filtered[0]; + + // Handle qualified: "Models::User" → "User" + const segments = typePart.split('::'); + const last = segments[segments.length - 1]; + + // Handle generic: "Array<User>" → "Array" + const genericMatch = last.match(/^(\w+)\s*[<{(]/); + if (genericMatch) return genericMatch[1]; + + // Simple identifier check + if (/^\w+$/.test(last)) return last; + + return undefined; +}; + +/** + * Collect YARD @param annotations from comment nodes preceding a method definition. + * Returns a map of paramName → typeName. + * + * In tree-sitter-ruby, comments are sibling nodes that appear before the method node. + * We walk backwards through preceding siblings collecting consecutive comment nodes. + */ +const collectYardParams = (methodNode: SyntaxNode): Map<string, string> => { + const params = new Map<string, string>(); + + // In tree-sitter-ruby, YARD comments preceding a method inside a class body + // are placed as children of the `class` node, NOT as siblings of the `method` + // inside `body_statement`. The AST structure is: + // + // class + // constant = "ClassName" + // comment = "# @param ..." ← sibling of body_statement + // comment = "# @param ..." ← sibling of body_statement + // body_statement + // method ← method is here, no preceding siblings + // + // For top-level methods (outside classes), comments ARE direct siblings. + // We handle both by checking: if method has no preceding comment siblings, + // look at parent (body_statement) siblings instead. + const commentTexts: string[] = []; + + const collectComments = (startNode: SyntaxNode): void => { + let sibling = startNode.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + commentTexts.unshift(sibling.text); + } else if (sibling.isNamed) { + break; + } + sibling = sibling.previousSibling; + } + }; + + // Try method's own siblings first (top-level methods) + collectComments(methodNode); + + // If no comments found and parent is body_statement, check parent's siblings + if (commentTexts.length === 0 && methodNode.parent?.type === 'body_statement') { + collectComments(methodNode.parent); + } + + // Parse all comment lines for @param annotations + const commentBlock = commentTexts.join('\n'); + let match: RegExpExecArray | null; + + // Reset regex state + YARD_PARAM_RE.lastIndex = 0; + while ((match = YARD_PARAM_RE.exec(commentBlock)) !== null) { + const paramName = match[1]; + const rawType = match[2]; + const typeName = extractYardTypeName(rawType); + if (typeName) { + params.set(paramName, typeName); + } + } + + // Also check alternate YARD order: @param [Type] name + YARD_PARAM_ALT_RE.lastIndex = 0; + while ((match = YARD_PARAM_ALT_RE.exec(commentBlock)) !== null) { + const rawType = match[1]; + const paramName = match[2]; + if (params.has(paramName)) continue; // standard format takes priority + const typeName = extractYardTypeName(rawType); + if (typeName) { + params.set(paramName, typeName); + } + } + + return params; +}; + +/** + * Ruby node types that may carry type bindings. + * - `method`/`singleton_method`: YARD @param annotations (via extractDeclaration) + * - `assignment`: Constructor inference like `user = User.new` (via extractInitializer; + * extractDeclaration returns early for these nodes) + */ +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'method', + 'singleton_method', + 'assignment', +]); + +/** + * Extract YARD annotations from method definitions. + * Pre-populates the scope env with parameter types before the + * standard parameter walk (which won't find types since Ruby has none). + */ +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + if (node.type !== 'method' && node.type !== 'singleton_method') return; + + const yardParams = collectYardParams(node); + if (yardParams.size === 0) return; + + // Pre-populate env with YARD type bindings for each parameter + for (const [paramName, typeName] of yardParams) { + env.set(paramName, typeName); + } +}; + +/** + * Ruby parameter extraction. + * Ruby parameters (identifiers inside method_parameters) have no inline + * type annotations. YARD types are already populated by extractDeclaration, + * so this is a no-op — the bindings are already in the env. + * + * We still register this to maintain the LanguageTypeConfig contract. + */ +const extractParameter: ParameterExtractor = (_node: SyntaxNode, _env: Map<string, string>): void => { + // Ruby parameters have no type annotations. + // YARD types are pre-populated by extractDeclaration. +}; + +/** + * Ruby constructor inference: user = User.new or service = Models::User.new + * Uses the shared extractRubyConstructorAssignment helper for AST matching, + * then resolves against locally-known class names. + */ +const extractInitializer: InitializerExtractor = (node, env, classNames): void => { + const result = extractRubyConstructorAssignment(node); + if (!result) return; + if (env.has(result.varName)) return; + if (classNames.has(result.calleeName)) { + env.set(result.varName, result.calleeName); + } +}; + +/** + * Extract return type from YARD `@return [Type]` annotation preceding a method. + * Reuses the same comment-walking strategy as collectYardParams: try direct + * siblings first, fall back to parent (body_statement) siblings for class methods. + */ +const extractReturnType: ReturnTypeExtractor = (node) => { + const search = (startNode: SyntaxNode): string | undefined => { + let sibling = startNode.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + const match = YARD_RETURN_RE.exec(sibling.text); + if (match) return extractYardTypeName(match[1]); + } else if (sibling.isNamed) { + break; + } + sibling = sibling.previousSibling; + } + return undefined; + }; + + const result = search(node); + if (result) return result; + + if (node.parent?.type === 'body_statement') { + return search(node.parent); + } + return undefined; +}; + +/** + * Ruby constructor binding scanner: captures both `user = User.new` and + * plain call assignments like `user = get_user()`. + * The `.new` pattern returns the class name directly; plain calls return the + * callee name for return-type inference via SymbolTable lookup. + */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + // Try the .new pattern first (returns class name directly) + const newResult = extractRubyConstructorAssignment(node); + if (newResult) return newResult; + + // Plain call assignment: user = get_user() / user = Models.create() + if (node.type !== 'assignment') return undefined; + const left = node.childForFieldName('left'); + const right = node.childForFieldName('right'); + if (!left || !right) return undefined; + if (left.type !== 'identifier' && left.type !== 'constant') return undefined; + if (right.type !== 'call') return undefined; + const method = right.childForFieldName('method'); + if (!method) return undefined; + const calleeName = extractSimpleTypeName(method); + if (!calleeName) return undefined; + return { varName: left.text, calleeName }; +}; + +/** Ruby method node types that carry a parameter list. */ +const RUBY_METHOD_NODE_TYPES = new Set(['method', 'singleton_method']); + +const FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set(['for']); + +/** + * Collect raw YARD @param type strings from comment nodes preceding a method. + * Unlike collectYardParams which returns simplified type names, this returns the + * raw bracket content (e.g., "Array<User>" not "Array") for element type extraction. + */ +const collectYardRawParams = (methodNode: SyntaxNode): Map<string, string> => { + const params = new Map<string, string>(); + const commentTexts: string[] = []; + + const collectComments = (startNode: SyntaxNode): void => { + let sibling = startNode.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + commentTexts.unshift(sibling.text); + } else if (sibling.isNamed) { + break; + } + sibling = sibling.previousSibling; + } + }; + + collectComments(methodNode); + if (commentTexts.length === 0 && methodNode.parent?.type === 'body_statement') { + collectComments(methodNode.parent); + } + + const commentBlock = commentTexts.join('\n'); + let match: RegExpExecArray | null; + + YARD_PARAM_RE.lastIndex = 0; + while ((match = YARD_PARAM_RE.exec(commentBlock)) !== null) { + params.set(match[1], match[2]); + } + YARD_PARAM_ALT_RE.lastIndex = 0; + while ((match = YARD_PARAM_ALT_RE.exec(commentBlock)) !== null) { + if (!params.has(match[2])) params.set(match[2], match[1]); + } + + return params; +}; + +/** + * Walk up the AST from a for-statement to find the enclosing method, + * then search its YARD @param annotations for one named `iterableName`. + * Returns the element type extracted from the raw YARD type string. + * + * Example: `@param users [Array<User>]` → extracts "User" from "Array<User>". + */ +const findRubyParamElementType = (iterableName: string, startNode: SyntaxNode): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (RUBY_METHOD_NODE_TYPES.has(current.type)) { + const rawParams = collectYardRawParams(current); + const rawType = rawParams.get(iterableName); + if (rawType) return extractElementTypeFromString(rawType); + break; + } + current = current.parent; + } + return undefined; +}; + +/** + * Ruby: for user in users ... end + * + * tree-sitter-ruby `for` node structure: + * pattern field: the loop variable (identifier) + * value field: `in` node whose child is the iterable expression + * + * Tier 1c: resolves the element type via: + * 1. scopeEnv string — extractElementTypeFromString on the stored type + * 2. AST walk — walks up to the enclosing method's YARD @param to read Array<User> directly + * + * Ruby has no static types on loop variables, so this mainly works when the + * iterable has a YARD-annotated container type (e.g., `@param users [Array<User>]`). + */ +const extractForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope }): void => { + if (node.type !== 'for') return; + + // The loop variable is the `pattern` field (identifier). + const patternNode = node.childForFieldName('pattern'); + if (!patternNode) return; + const loopVarName = extractVarName(patternNode); + if (!loopVarName) return; + + // The iterable is inside the `value` field which is an `in` node wrapping the expression. + const inNode = node.childForFieldName('value'); + if (!inNode) return; + const iterableNode = inNode.firstNamedChild; + let iterableName: string | undefined; + if (iterableNode?.type === 'identifier') { + iterableName = iterableNode.text; + } else if (iterableNode?.type === 'call') { + const method = iterableNode.childForFieldName('method'); + if (method) iterableName = method.text; + } + if (!iterableName) return; + + // Ruby has no extractFromTypeNode (no AST type annotations), pass a no-op. + const noopExtractFromTypeNode = (): string | undefined => undefined; + + const elementType = resolveIterableElementType( + iterableName, node, scopeEnv, declarationTypeNodes, scope, + noopExtractFromTypeNode, findRubyParamElementType, + undefined, + ); + if (!elementType) return; + + scopeEnv.set(loopVarName, elementType); +}; + +/** + * Ruby: alias_user = user → assignment with left/right identifier fields. + * Only handles plain identifier RHS (not calls, not literals). + * Skips if LHS already has a resolved type in scopeEnv. + */ +const extractPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + if (node.type !== 'assignment') return undefined; + const lhsNode = node.childForFieldName('left'); + if (!lhsNode || lhsNode.type !== 'identifier') return undefined; + const varName = lhsNode.text; + if (scopeEnv.has(varName)) return undefined; + const rhsNode = node.childForFieldName('right'); + if (!rhsNode || rhsNode.type !== 'identifier') return undefined; + return { kind: 'copy', lhs: varName, rhs: rhsNode.text }; +}; + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + forLoopNodeTypes: FOR_LOOP_NODE_TYPES, + extractDeclaration, + extractParameter, + extractInitializer, + scanConstructorBinding, + extractReturnType, + extractForLoopBinding, + extractPendingAssignment, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/rust.ts b/gitnexus/src/core/ingestion/type-extractors/rust.ts new file mode 100644 index 0000000000..c3d389638f --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/rust.ts @@ -0,0 +1,427 @@ +import type { SyntaxNode } from '../utils.js'; +import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, PendingAssignmentExtractor, PatternBindingExtractor, ForLoopExtractor } from './types.js'; +import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, type TypeArgPosition } from './shared.js'; + +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'let_declaration', + 'let_condition', +]); + +/** Walk up the AST to find the enclosing impl block and extract the implementing type name. */ +const findEnclosingImplType = (node: SyntaxNode): string | undefined => { + let current = node.parent; + while (current) { + if (current.type === 'impl_item') { + // The 'type' field holds the implementing type (e.g., `impl User { ... }`) + const typeNode = current.childForFieldName('type'); + if (typeNode) return extractSimpleTypeName(typeNode); + } + current = current.parent; + } + return undefined; +}; + +/** + * Extract the type name from a struct_pattern's 'type' field. + * Handles both simple `User { .. }` and scoped `Message::Data { .. }`. + */ +const extractStructPatternType = (structPattern: SyntaxNode): string | undefined => { + const typeNode = structPattern.childForFieldName('type'); + if (!typeNode) return undefined; + return extractSimpleTypeName(typeNode); +}; + +/** + * Recursively scan a pattern tree for captured_pattern nodes (x @ StructType { .. }) + * and extract variable → type bindings from them. + */ +const extractCapturedPatternBindings = (pattern: SyntaxNode, env: Map<string, string>, depth = 0): void => { + if (depth > 50) return; + if (pattern.type === 'captured_pattern') { + // captured_pattern: identifier @ inner_pattern + // The first named child is the identifier, followed by the inner pattern. + const nameNode = pattern.firstNamedChild; + if (!nameNode || nameNode.type !== 'identifier') return; + // Find the struct_pattern child — that gives us the type + for (let i = 0; i < pattern.namedChildCount; i++) { + const child = pattern.namedChild(i); + if (child?.type === 'struct_pattern') { + const typeName = extractStructPatternType(child); + if (typeName) env.set(nameNode.text, typeName); + return; + } + } + return; + } + // Recurse into tuple_struct_pattern children to find nested captured_patterns + // e.g., Some(user @ User { .. }) + if (pattern.type === 'tuple_struct_pattern') { + for (let i = 0; i < pattern.namedChildCount; i++) { + const child = pattern.namedChild(i); + if (child) extractCapturedPatternBindings(child, env, depth + 1); + } + } +}; + +/** Rust: let x: Foo = ... | if let / while let pattern bindings */ +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + if (node.type === 'let_condition') { + // if let / while let: extract type bindings from pattern matching. + // + // Supported patterns: + // - captured_pattern: `if let user @ User { .. } = expr` → user: User + // - tuple_struct_pattern with nested captured_pattern: + // `if let Some(user @ User { .. }) = expr` → user: User + // + // NOT supported (requires generic unwrapping — Phase 3): + // - `if let Some(x) = opt` where opt: Option<T> → x: T + // + // struct_pattern without capture (`if let User { name } = expr`) + // destructures fields — individual field types are unknown without + // field-type resolution, so no bindings are extracted. + const pattern = node.childForFieldName('pattern'); + if (!pattern) return; + extractCapturedPatternBindings(pattern, env); + return; + } + + // Standard let_declaration: let x: Foo = ... + const pattern = node.childForFieldName('pattern'); + const typeNode = node.childForFieldName('type'); + if (!pattern || !typeNode) return; + const varName = extractVarName(pattern); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Rust: let x = User::new(), let x = User::default(), or let x = User { ... } */ +const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup): void => { + // Skip if there's an explicit type annotation — Tier 0 already handled it + if (node.childForFieldName('type') !== null) return; + const pattern = node.childForFieldName('pattern'); + const value = node.childForFieldName('value'); + if (!pattern || !value) return; + + // Rust struct literal: let user = User { name: "alice", age: 30 } + // tree-sitter-rust: struct_expression with 'name' field holding the type + if (value.type === 'struct_expression') { + const typeNode = value.childForFieldName('name'); + if (!typeNode) return; + const rawType = extractSimpleTypeName(typeNode); + if (!rawType) return; + // Resolve Self to the actual struct/enum name from the enclosing impl block + const typeName = rawType === 'Self' ? findEnclosingImplType(node) : rawType; + const varName = extractVarName(pattern); + if (varName && typeName) env.set(varName, typeName); + return; + } + + // Unit struct instantiation: let svc = UserService; (bare identifier, no braces or call) + if (value.type === 'identifier' && classNames.has(value.text)) { + const varName = extractVarName(pattern); + if (varName) env.set(varName, value.text); + return; + } + + if (value.type !== 'call_expression') return; + const func = value.childForFieldName('function'); + if (!func || func.type !== 'scoped_identifier') return; + const nameField = func.childForFieldName('name'); + // Only match ::new() and ::default() — the two idiomatic Rust constructors. + // Deliberately excludes ::from(), ::with_capacity(), etc. to avoid false positives + // (e.g. String::from("x") is not necessarily the "String" type we want for method resolution). + if (!nameField || (nameField.text !== 'new' && nameField.text !== 'default')) return; + const pathField = func.childForFieldName('path'); + if (!pathField) return; + const rawType = extractSimpleTypeName(pathField); + if (!rawType) return; + // Resolve Self to the actual struct/enum name from the enclosing impl block + const typeName = rawType === 'Self' ? findEnclosingImplType(node) : rawType; + const varName = extractVarName(pattern); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Rust: parameter → pattern: type */ +const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'parameter') { + nameNode = node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } else { + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Rust: let user = get_user("alice") — let_declaration with call_expression value, no type annotation. + * Skips `let user: User = ...` (explicit type annotation — handled by extractDeclaration). + * Skips `let user = User::new()` (scoped_identifier callee named "new" — handled by extractInitializer). + * Unwraps `let mut user = get_user()` by looking inside mut_pattern for the inner identifier. + */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'let_declaration') return undefined; + if (hasTypeAnnotation(node)) return undefined; + let patternNode = node.childForFieldName('pattern'); + if (!patternNode) return undefined; + if (patternNode.type === 'mut_pattern') { + patternNode = patternNode.firstNamedChild; + if (!patternNode) return undefined; + } + if (patternNode.type !== 'identifier') return undefined; + // Unwrap `.await`: `let user = get_user().await` → await_expression wraps call_expression + const value = unwrapAwait(node.childForFieldName('value')); + if (!value || value.type !== 'call_expression') return undefined; + const func = value.childForFieldName('function'); + if (!func) return undefined; + if (func.type === 'scoped_identifier') { + const methodName = func.lastNamedChild; + if (methodName?.text === 'new' || methodName?.text === 'default') return undefined; + } + const calleeName = extractSimpleTypeName(func); + if (!calleeName) return undefined; + return { varName: patternNode.text, calleeName }; +}; + +/** Rust: let alias = u; → let_declaration with pattern + value fields */ +const extractPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + if (node.type !== 'let_declaration') return undefined; + const pattern = node.childForFieldName('pattern'); + const value = node.childForFieldName('value'); + if (!pattern || !value) return undefined; + const lhs = extractVarName(pattern); + if (!lhs || scopeEnv.has(lhs)) return undefined; + if (value.type === 'identifier') return { kind: 'copy', lhs, rhs: value.text }; + return undefined; +}; + +/** + * Rust pattern binding extractor for `if let` / `while let` constructs that unwrap + * enum variants and introduce new typed variables. + * + * Supported patterns: + * - `if let Some(x) = opt` → x: T (opt: Option<T>, T already in scopeEnv via NULLABLE_WRAPPER_TYPES) + * - `if let Ok(x) = res` → x: T (res: Result<T, E>, T extracted from declarationTypeNodes) + * + * These complement the captured_pattern support in extractDeclaration (which handles + * `if let x @ Struct { .. } = expr` but NOT tuple struct unwrapping like Some(x) / Ok(x)). + * + * Conservative: returns undefined when: + * - The source variable's type is unknown (not in scopeEnv) + * - The wrapper is not a known single-unwrap variant (Some / Ok) + * - The value side is not a simple identifier + */ +const extractPatternBinding: PatternBindingExtractor = ( + node, + scopeEnv, + declarationTypeNodes, + scope, +) => { + let patternNode: SyntaxNode | null = null; + let valueNode: SyntaxNode | null = null; + + if (node.type === 'let_condition') { + patternNode = node.childForFieldName('pattern'); + valueNode = node.childForFieldName('value'); + } else if (node.type === 'match_arm') { + // match_arm → pattern field is match_pattern wrapping the actual pattern + const matchPatternNode = node.childForFieldName('pattern'); + // Unwrap match_pattern to get the tuple_struct_pattern inside + patternNode = matchPatternNode?.type === 'match_pattern' + ? matchPatternNode.firstNamedChild + : matchPatternNode; + // source variable is in the parent match_expression's 'value' field + const matchExpr = node.parent?.parent; // match_arm → match_block → match_expression + if (matchExpr?.type === 'match_expression') { + valueNode = matchExpr.childForFieldName('value'); + } + } + if (!patternNode || !valueNode) return undefined; + + // Only handle tuple_struct_pattern: Some(x) or Ok(x) + if (patternNode.type !== 'tuple_struct_pattern') return undefined; + + // Extract the wrapper type name: Some | Ok + const wrapperTypeNode = patternNode.childForFieldName('type'); + if (!wrapperTypeNode) return undefined; + const wrapperName = extractSimpleTypeName(wrapperTypeNode); + if (wrapperName !== 'Some' && wrapperName !== 'Ok' && wrapperName !== 'Err') return undefined; + + // Extract the inner variable name from the single child of the tuple_struct_pattern. + // `Some(x)` → the first named child after the type field is the identifier. + // tree-sitter-rust: tuple_struct_pattern has 'type' field + unnamed children for args. + let innerVar: string | undefined; + for (let i = 0; i < patternNode.namedChildCount; i++) { + const child = patternNode.namedChild(i); + if (!child) continue; + // Skip the type node itself + if (child === wrapperTypeNode) continue; + if (child.type === 'identifier') { + innerVar = child.text; + break; + } + } + if (!innerVar) return undefined; + + // The value must be a simple identifier so we can look it up in scopeEnv + const sourceVarName = valueNode.type === 'identifier' ? valueNode.text : undefined; + if (!sourceVarName) return undefined; + + // For `Some(x)`: Option<T> is already unwrapped to T in scopeEnv (via NULLABLE_WRAPPER_TYPES). + // For `Ok(x)`: Result<T, E> stores "Result" in scopeEnv — must use declarationTypeNodes. + if (wrapperName === 'Some') { + const innerType = scopeEnv.get(sourceVarName); + if (!innerType) return undefined; + return { varName: innerVar, typeName: innerType }; + } + + // wrapperName === 'Ok' or 'Err': look up the Result<T, E> type AST node. + // Ok(x) → extract T (typeArgs[0]), Err(e) → extract E (typeArgs[1]). + const typeNodeKey = `${scope}\0${sourceVarName}`; + const typeAstNode = declarationTypeNodes.get(typeNodeKey); + if (!typeAstNode) return undefined; + const typeArgs = extractGenericTypeArgs(typeAstNode); + const argIndex = wrapperName === 'Err' ? 1 : 0; + if (typeArgs.length < argIndex + 1) return undefined; + return { varName: innerVar, typeName: typeArgs[argIndex] }; +}; + +// --- For-loop Tier 1c --- + +const FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set(['for_expression']); + +/** Extract element type from a Rust type annotation AST node. + * Handles: generic_type (Vec<User>), reference_type (&[User]), array_type ([User; N]), + * slice_type ([User]). For call-graph purposes, strips references (&User → User). */ +const extractRustElementTypeFromTypeNode = (typeNode: SyntaxNode, pos: TypeArgPosition = 'last', depth = 0): string | undefined => { + if (depth > 50) return undefined; + // generic_type: Vec<User>, HashMap<K, V> — extract type arg based on position + if (typeNode.type === 'generic_type') { + const args = extractGenericTypeArgs(typeNode); + if (args.length >= 1) return pos === 'first' ? args[0] : args[args.length - 1]; + } + // reference_type: &[User] or &Vec<User> — unwrap the reference and recurse + if (typeNode.type === 'reference_type') { + const inner = typeNode.lastNamedChild; + if (inner) return extractRustElementTypeFromTypeNode(inner, pos, depth + 1); + } + // array_type: [User; N] — element is the first child + if (typeNode.type === 'array_type') { + const elemNode = typeNode.firstNamedChild; + if (elemNode) return extractSimpleTypeName(elemNode); + } + // slice_type: [User] — element is the first child + if (typeNode.type === 'slice_type') { + const elemNode = typeNode.firstNamedChild; + if (elemNode) return extractSimpleTypeName(elemNode); + } + return undefined; +}; + +/** Walk up from a for-loop to the enclosing function_item and search parameters + * for one named `iterableName`. Returns the element type from its annotation. */ +const findRustParamElementType = (iterableName: string, startNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + while (current) { + if (current.type === 'function_item') { + const paramsNode = current.childForFieldName('parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const param = paramsNode.namedChild(i); + if (!param || param.type !== 'parameter') continue; + const nameNode = param.childForFieldName('pattern'); + if (!nameNode) continue; + // Unwrap reference patterns: &users, &mut users + let identNode = nameNode; + if (identNode.type === 'reference_pattern') { + identNode = identNode.lastNamedChild ?? identNode; + } + if (identNode.type === 'mut_pattern') { + identNode = identNode.firstNamedChild ?? identNode; + } + if (identNode.text !== iterableName) continue; + const typeNode = param.childForFieldName('type'); + if (typeNode) return extractRustElementTypeFromTypeNode(typeNode, pos); + } + } + break; + } + current = current.parent; + } + return undefined; +}; + +/** Rust: for user in &users where users has a known container type. + * Unwraps reference_expression (&users, &mut users) to get the iterable name. */ +const extractForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }): void => { + if (node.type !== 'for_expression') return; + + const patternNode = node.childForFieldName('pattern'); + const valueNode = node.childForFieldName('value'); + if (!patternNode || !valueNode) return; + + // Extract iterable name + method — may be &users, users, or users.iter()/keys()/values() + let iterableName: string | undefined; + let methodName: string | undefined; + let callExprElementType: string | undefined; + if (valueNode.type === 'reference_expression') { + const inner = valueNode.lastNamedChild; + if (inner?.type === 'identifier') iterableName = inner.text; + } else if (valueNode.type === 'identifier') { + iterableName = valueNode.text; + } else if (valueNode.type === 'field_expression') { + const prop = valueNode.lastNamedChild; + if (prop) iterableName = prop.text; + } else if (valueNode.type === 'call_expression') { + const funcExpr = valueNode.childForFieldName('function'); + if (funcExpr?.type === 'field_expression') { + // users.iter() → field_expression > identifier + field_identifier + const obj = funcExpr.firstNamedChild; + if (obj?.type === 'identifier') iterableName = obj.text; + // Extract method name: iter, keys, values, into_iter, etc. + const field = funcExpr.lastNamedChild; + if (field?.type === 'field_identifier') methodName = field.text; + } else if (funcExpr?.type === 'identifier') { + // Direct function call: for user in get_users() + const rawReturn = returnTypeLookup.lookupRawReturnType(funcExpr.text); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + } + if (!iterableName && !callExprElementType) return; + + let elementType: string | undefined; + if (callExprElementType) { + elementType = callExprElementType; + } else { + const containerTypeName = scopeEnv.get(iterableName!); + const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName); + elementType = resolveIterableElementType( + iterableName!, node, scopeEnv, declarationTypeNodes, scope, + extractRustElementTypeFromTypeNode, findRustParamElementType, + typeArgPos, + ); + } + if (!elementType) return; + + const loopVarName = extractVarName(patternNode); + if (loopVarName) scopeEnv.set(loopVarName, elementType); +}; + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + forLoopNodeTypes: FOR_LOOP_NODE_TYPES, + patternBindingNodeTypes: new Set(['let_condition', 'match_arm']), + extractDeclaration, + extractInitializer, + extractParameter, + scanConstructorBinding, + extractForLoopBinding, + extractPendingAssignment, + extractPatternBinding, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/shared.ts b/gitnexus/src/core/ingestion/type-extractors/shared.ts new file mode 100644 index 0000000000..e04d1f2a06 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/shared.ts @@ -0,0 +1,852 @@ +import type { SyntaxNode } from '../utils.js'; + +/** Which type argument to extract from a multi-arg generic container. + * - 'first': key type (e.g., K from Map<K,V>) — used for .keys(), .keySet() + * - 'last': value type (e.g., V from Map<K,V>) — used for .values(), .items(), .iter() */ +export type TypeArgPosition = 'first' | 'last'; + +// --------------------------------------------------------------------------- +// Container type descriptors — maps container base names to type parameter +// semantics per access method. Replaces the simple KEY_METHODS heuristic. +// +// For user-defined generics (MyCache<K,V> extends Map<K,V>), heritage-aware +// fallback can walk the EXTENDS chain to find a matching descriptor. +// --------------------------------------------------------------------------- + +/** Describes which type parameter position each access method yields. */ +interface ContainerDescriptor { + /** Number of type parameters (1 = single-element, 2 = key-value) */ + arity: number; + /** Methods that yield the first type parameter (key type for maps) */ + keyMethods: ReadonlySet<string>; + /** Methods that yield the last type parameter (value type) */ + valueMethods: ReadonlySet<string>; +} + +/** Empty set for containers that have no key-yielding methods */ +const NO_KEYS: ReadonlySet<string> = new Set(); + +/** Standard key-yielding methods across languages */ +const STD_KEY_METHODS: ReadonlySet<string> = new Set(['keys']); +const JAVA_KEY_METHODS: ReadonlySet<string> = new Set(['keySet']); +const CSHARP_KEY_METHODS: ReadonlySet<string> = new Set(['Keys']); + +/** Standard value-yielding methods across languages */ +const STD_VALUE_METHODS: ReadonlySet<string> = new Set(['values', 'get', 'pop', 'remove']); +const CSHARP_VALUE_METHODS: ReadonlySet<string> = new Set(['Values', 'TryGetValue']); +const SINGLE_ELEMENT_METHODS: ReadonlySet<string> = new Set([ + 'iter', 'into_iter', 'iterator', 'get', 'first', 'last', 'pop', + 'peek', 'poll', 'find', 'filter', 'map', +]); + +const CONTAINER_DESCRIPTORS: ReadonlyMap<string, ContainerDescriptor> = new Map([ + // --- Map / Dict types (arity 2: key + value) --- + ['Map', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['WeakMap', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['HashMap', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['BTreeMap', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['LinkedHashMap', { arity: 2, keyMethods: JAVA_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['TreeMap', { arity: 2, keyMethods: JAVA_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['dict', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['Dict', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['Dictionary', { arity: 2, keyMethods: CSHARP_KEY_METHODS, valueMethods: CSHARP_VALUE_METHODS }], + ['SortedDictionary', { arity: 2, keyMethods: CSHARP_KEY_METHODS, valueMethods: CSHARP_VALUE_METHODS }], + ['Record', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['OrderedDict', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['ConcurrentHashMap', { arity: 2, keyMethods: JAVA_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['ConcurrentDictionary', { arity: 2, keyMethods: CSHARP_KEY_METHODS, valueMethods: CSHARP_VALUE_METHODS }], + + // --- Single-element containers (arity 1) --- + ['Array', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['List', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['ArrayList', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['LinkedList',{ arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Vec', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['VecDeque', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Set', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['HashSet', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['BTreeSet', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['TreeSet', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Queue', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Deque', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Stack', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Sequence', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Iterable', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Iterator', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['IEnumerable', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['IList', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['ICollection', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Collection', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['ObservableCollection', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['IEnumerator', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['SortedSet', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['Stream', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['MutableList', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['MutableSet', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['LinkedHashSet', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['ArrayDeque', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['PriorityQueue', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['MutableMap', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }], + ['list', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['set', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['tuple', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], + ['frozenset', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }], +]); + +/** Determine which type arg to extract based on container type name and access method. + * + * Resolution order: + * 1. If container is known and method is in keyMethods → 'first' + * 2. If container is known with arity 1 → 'last' (same as 'first' for single-arg) + * 3. If container is unknown → fall back to method name heuristic + * 4. Default: 'last' (value type) + */ +export function methodToTypeArgPosition(methodName: string | undefined, containerTypeName?: string): TypeArgPosition { + if (containerTypeName) { + const desc = CONTAINER_DESCRIPTORS.get(containerTypeName); + if (desc) { + // Single-element container: always 'last' (= only arg) + if (desc.arity === 1) return 'last'; + // Multi-element: check if method yields key type + if (methodName && desc.keyMethods.has(methodName)) return 'first'; + // Default for multi-element: value type + return 'last'; + } + } + // Fallback for unknown containers: simple method name heuristic + if (methodName && (methodName === 'keys' || methodName === 'keySet' || methodName === 'Keys')) { + return 'first'; + } + return 'last'; +} + +/** Look up the container descriptor for a type name. Exported for heritage-chain lookups. */ +export function getContainerDescriptor(typeName: string): ContainerDescriptor | undefined { + return CONTAINER_DESCRIPTORS.get(typeName); +} + +/** + * Shared 3-strategy fallback for resolving the element type of a container variable. + * Used by all for-loop extractors to resolve the loop variable's type from the iterable. + * + * Strategy 1: declarationTypeNodes — raw AST type annotation node (handles container types + * where extractSimpleTypeName returned undefined, e.g., User[], List[User]) + * Strategy 2: scopeEnv string — extractElementTypeFromString on the stored type string + * Strategy 3: AST walk — language-specific upward walk to enclosing function parameters + * + * @param extractFromTypeNode Language-specific function to extract element type from AST node + * @param findParamElementType Optional language-specific AST walk to find parameter type + * @param typeArgPos Which generic type arg to extract: 'first' for keys, 'last' for values (default) + */ +export function resolveIterableElementType( + iterableName: string, + node: SyntaxNode, + scopeEnv: ReadonlyMap<string, string>, + declarationTypeNodes: ReadonlyMap<string, SyntaxNode>, + scope: string, + extractFromTypeNode: (typeNode: SyntaxNode, pos?: TypeArgPosition) => string | undefined, + findParamElementType?: (name: string, startNode: SyntaxNode, pos?: TypeArgPosition) => string | undefined, + typeArgPos: TypeArgPosition = 'last', +): string | undefined { + // Strategy 1: declarationTypeNodes AST node (check current scope, then file scope) + const typeNode = declarationTypeNodes.get(`${scope}\0${iterableName}`) + ?? (scope !== '' ? declarationTypeNodes.get(`\0${iterableName}`) : undefined); + if (typeNode) { + const t = extractFromTypeNode(typeNode, typeArgPos); + if (t) return t; + } + // Strategy 2: scopeEnv string → extractElementTypeFromString + const iterableType = scopeEnv.get(iterableName); + if (iterableType) { + const el = extractElementTypeFromString(iterableType, typeArgPos); + if (el) return el; + } + // Strategy 3: AST walk to function parameters + if (findParamElementType) return findParamElementType(iterableName, node, typeArgPos); + return undefined; +} + +/** Known single-arg nullable wrapper types that unwrap to their inner type + * for receiver resolution. Optional<User> → "User", Option<User> → "User". + * Only nullable wrappers — NOT containers (List, Vec) or async wrappers (Promise, Future). + * See WRAPPER_GENERICS below for the full set used in return-type inference. */ +const NULLABLE_WRAPPER_TYPES = new Set([ + 'Optional', // Java + 'Option', // Rust, Scala + 'Maybe', // Haskell-style, Kotlin Arrow +]); + +/** + * Extract the simple type name from a type AST node. + * Handles generic types (e.g., List<User> → List), qualified names + * (e.g., models.User → User), and nullable types (e.g., User? → User). + * Returns undefined for complex types (unions, intersections, function types). + */ +export const extractSimpleTypeName = (typeNode: SyntaxNode, depth = 0): string | undefined => { + if (depth > 50 || typeNode.text.length > 2048) return undefined; + // Direct type identifier (includes Ruby 'constant' for class names) + if (typeNode.type === 'type_identifier' || typeNode.type === 'identifier' + || typeNode.type === 'simple_identifier' || typeNode.type === 'constant') { + return typeNode.text; + } + + // Qualified/scoped names: take the last segment (e.g., models.User → User, Models::User → User) + if (typeNode.type === 'scoped_identifier' || typeNode.type === 'qualified_identifier' + || typeNode.type === 'scoped_type_identifier' || typeNode.type === 'qualified_name' + || typeNode.type === 'qualified_type' + || typeNode.type === 'member_expression' || typeNode.type === 'member_access_expression' + || typeNode.type === 'attribute' + || typeNode.type === 'scope_resolution' + || typeNode.type === 'selector_expression') { + const last = typeNode.lastNamedChild; + if (last && (last.type === 'type_identifier' || last.type === 'identifier' + || last.type === 'simple_identifier' || last.type === 'name' + || last.type === 'constant' || last.type === 'property_identifier' + || last.type === 'field_identifier')) { + return last.text; + } + } + + // C++ template_type (e.g., vector<User>, map<string, User>): extract base name + if (typeNode.type === 'template_type') { + const base = typeNode.childForFieldName('name') ?? typeNode.firstNamedChild; + if (base) return extractSimpleTypeName(base, depth + 1); + } + + // Generic types: extract the base type (e.g., List<User> → List) + // For nullable wrappers (Optional<User>, Option<User>), unwrap to inner type. + if (typeNode.type === 'generic_type' || typeNode.type === 'parameterized_type' + || typeNode.type === 'generic_name') { + const base = typeNode.childForFieldName('name') + ?? typeNode.childForFieldName('type') + ?? typeNode.firstNamedChild; + if (!base) return undefined; + const baseName = extractSimpleTypeName(base, depth + 1); + // Unwrap known nullable wrappers: Optional<User> → User, Option<User> → User + if (baseName && NULLABLE_WRAPPER_TYPES.has(baseName)) { + const args = extractGenericTypeArgs(typeNode); + if (args.length >= 1) return args[0]; + } + return baseName; + } + + // Nullable types (Kotlin User?, C# User?) + if (typeNode.type === 'nullable_type') { + const inner = typeNode.firstNamedChild; + if (inner) return extractSimpleTypeName(inner, depth + 1); + } + + // Nullable union types (TS/JS: User | null, User | undefined, User | null | undefined) + // Extract the single non-null/undefined type from the union. + if (typeNode.type === 'union_type') { + const nonNullTypes: SyntaxNode[] = []; + for (let i = 0; i < typeNode.namedChildCount; i++) { + const child = typeNode.namedChild(i); + if (!child) continue; + // Skip null/undefined/void literal types + const text = child.text; + if (text === 'null' || text === 'undefined' || text === 'void') continue; + nonNullTypes.push(child); + } + // Only unwrap if exactly one meaningful type remains + if (nonNullTypes.length === 1) { + return extractSimpleTypeName(nonNullTypes[0], depth + 1); + } + } + + // Type annotations that wrap the actual type (TS/Python: `: Foo`, Kotlin: user_type) + if (typeNode.type === 'type_annotation' || typeNode.type === 'type' + || typeNode.type === 'user_type') { + const inner = typeNode.firstNamedChild; + if (inner) return extractSimpleTypeName(inner, depth + 1); + } + + // Pointer/reference types (C++, Rust): User*, &User, &mut User + if (typeNode.type === 'pointer_type' || typeNode.type === 'reference_type') { + // Skip mutable_specifier for Rust &mut references — firstNamedChild would be + // `mutable_specifier` not the actual type. Walk named children to find the type. + for (let i = 0; i < typeNode.namedChildCount; i++) { + const child = typeNode.namedChild(i); + if (child && child.type !== 'mutable_specifier') { + return extractSimpleTypeName(child, depth + 1); + } + } + } + + // Primitive/predefined types: string, int, float, bool, number, unknown, any + // PHP: primitive_type; TS/JS: predefined_type + if (typeNode.type === 'primitive_type' || typeNode.type === 'predefined_type') { + return typeNode.text; + } + + // PHP named_type / optional_type + if (typeNode.type === 'named_type' || typeNode.type === 'optional_type') { + const inner = typeNode.childForFieldName('name') ?? typeNode.firstNamedChild; + if (inner) return extractSimpleTypeName(inner, depth + 1); + } + + // Name node (PHP) + if (typeNode.type === 'name') { + return typeNode.text; + } + + return undefined; +}; + +/** + * Extract variable name from a declarator or pattern node. + * Returns the simple identifier text, or undefined for destructuring/complex patterns. + */ +export const extractVarName = (node: SyntaxNode): string | undefined => { + if (node.type === 'identifier' || node.type === 'simple_identifier' + || node.type === 'variable_name' || node.type === 'name' + || node.type === 'constant' || node.type === 'property_identifier') { + return node.text; + } + // variable_declarator (Java/C#): has a 'name' field + if (node.type === 'variable_declarator') { + const nameChild = node.childForFieldName('name'); + if (nameChild) return extractVarName(nameChild); + } + // Rust: let mut x = ... — mut_pattern wraps an identifier + if (node.type === 'mut_pattern') { + const inner = node.firstNamedChild; + if (inner) return extractVarName(inner); + } + return undefined; +}; + +/** Node types for function/method parameters with type annotations */ +export const TYPED_PARAMETER_TYPES = new Set([ + 'required_parameter', // TS: (x: Foo) + 'optional_parameter', // TS: (x?: Foo) + 'formal_parameter', // Java/Kotlin + 'parameter', // C#/Rust/Go/Python/Swift + 'typed_parameter', // Python: def f(x: Foo) — distinct from 'parameter' in tree-sitter-python + 'parameter_declaration', // C/C++ void f(Type name) + 'simple_parameter', // PHP function(Foo $x) + 'property_promotion_parameter', // PHP 8.0+ constructor promotion: __construct(private Foo $x) + 'closure_parameter', // Rust: |user: User| — typed closure parameters +]); + +/** + * Extract type arguments from a generic type node. + * e.g., List<User, String> → ['User', 'String'], Vec<User> → ['User'] + * + * Used by extractSimpleTypeName to unwrap nullable wrappers (Optional<User> → User). + * + * Handles language-specific AST structures: + * - TS/Java/Rust/Go: generic_type > type_arguments > type nodes + * - C#: generic_type > type_argument_list > type nodes + * - Kotlin: generic_type > type_arguments > type_projection > type nodes + * + * Note: Go slices/maps use slice_type/map_type, not generic_type — those are + * NOT handled here. Use language-specific extractors for Go container types. + * + * @param typeNode A generic_type or parameterized_type AST node (or any node — + * returns [] for non-generic types). + * @returns Array of resolved type argument names. Unresolvable arguments are omitted. + */ +export const extractGenericTypeArgs = (typeNode: SyntaxNode, depth = 0): string[] => { + if (depth > 50) return []; + // Unwrap wrapper nodes that may sit above the generic_type + if (typeNode.type === 'type_annotation' || typeNode.type === 'type' + || typeNode.type === 'user_type' || typeNode.type === 'nullable_type' + || typeNode.type === 'optional_type') { + const inner = typeNode.firstNamedChild; + if (inner) return extractGenericTypeArgs(inner, depth + 1); + return []; + } + + // Only process generic/parameterized type nodes (includes C#'s generic_name) + if (typeNode.type !== 'generic_type' && typeNode.type !== 'parameterized_type' + && typeNode.type !== 'generic_name') { + return []; + } + + // Find the type_arguments / type_argument_list child + let argsNode: SyntaxNode | null = null; + for (let i = 0; i < typeNode.namedChildCount; i++) { + const child = typeNode.namedChild(i); + if (child && (child.type === 'type_arguments' || child.type === 'type_argument_list')) { + argsNode = child; + break; + } + } + if (!argsNode) return []; + + const result: string[] = []; + for (let i = 0; i < argsNode.namedChildCount; i++) { + let argNode = argsNode.namedChild(i); + if (!argNode) continue; + + // Kotlin: type_arguments > type_projection > user_type > type_identifier + if (argNode.type === 'type_projection') { + argNode = argNode.firstNamedChild; + if (!argNode) continue; + } + + const name = extractSimpleTypeName(argNode); + if (name) result.push(name); + } + + return result; +}; + +/** + * Match Ruby constructor assignment: `user = User.new` or `service = Models::User.new`. + * Returns { varName, calleeName } or undefined if the node is not a Ruby constructor assignment. + * Handles both simple constants and scope_resolution (namespaced) receivers. + */ +export const extractRubyConstructorAssignment = ( + node: SyntaxNode, +): { varName: string; calleeName: string } | undefined => { + if (node.type !== 'assignment') return undefined; + const left = node.childForFieldName('left'); + const right = node.childForFieldName('right'); + if (!left || !right) return undefined; + if (left.type !== 'identifier' && left.type !== 'constant') return undefined; + if (right.type !== 'call') return undefined; + const method = right.childForFieldName('method'); + if (!method || method.text !== 'new') return undefined; + const receiver = right.childForFieldName('receiver'); + if (!receiver) return undefined; + let calleeName: string; + if (receiver.type === 'constant') { + calleeName = receiver.text; + } else if (receiver.type === 'scope_resolution') { + // Models::User → extract last segment "User" + const last = receiver.lastNamedChild; + if (!last || last.type !== 'constant') return undefined; + calleeName = last.text; + } else { + return undefined; + } + return { varName: left.text, calleeName }; +}; + +/** + * Check if an AST node has an explicit type annotation. + * Checks both named fields ('type') and child nodes ('type_annotation'). + * Used by constructor binding scanners to skip annotated declarations. + */ +export const hasTypeAnnotation = (node: SyntaxNode): boolean => { + if (node.childForFieldName('type')) return true; + for (let i = 0; i < node.childCount; i++) { + if (node.child(i)?.type === 'type_annotation') return true; + } + return false; +}; + +/** Bare nullable keywords that should not produce a receiver binding. */ +const NULLABLE_KEYWORDS = new Set(['null', 'undefined', 'void', 'None', 'nil']); + +/** + * Strip nullable wrappers from a type name string. + * Used by both lookupInEnv (TypeEnv annotations) and extractReturnTypeName + * (return-type text) to normalize types before receiver lookup. + * + * "User | null" → "User" + * "User | undefined" → "User" + * "User | null | undefined" → "User" + * "User?" → "User" + * "User | Repo" → undefined (genuine union — refuse) + * "null" → undefined + */ +export const stripNullable = (typeName: string): string | undefined => { + let text = typeName.trim(); + if (!text) return undefined; + + if (NULLABLE_KEYWORDS.has(text)) return undefined; + + // Strip nullable suffix: User? → User + if (text.endsWith('?')) text = text.slice(0, -1).trim(); + + // Strip union with null/undefined/None/nil/void + if (text.includes('|')) { + const parts = text.split('|').map(p => p.trim()).filter(p => + p !== '' && !NULLABLE_KEYWORDS.has(p) + ); + if (parts.length === 1) return parts[0]; + return undefined; // genuine union or all-nullable — refuse + } + + return text || undefined; +}; + +/** + * Unwrap an await_expression to get the inner value. + * Returns the node itself if not an await_expression, or null if input is null. + */ +export const unwrapAwait = (node: SyntaxNode | null): SyntaxNode | null => { + if (!node) return null; + return node.type === 'await_expression' ? node.firstNamedChild : node; +}; + +/** + * Extract the callee name from a call_expression node. + * Navigates to the 'function' field (or first named child) and extracts a simple type name. + */ +export const extractCalleeName = (callNode: SyntaxNode): string | undefined => { + const func = callNode.childForFieldName('function') ?? callNode.firstNamedChild; + if (!func) return undefined; + return extractSimpleTypeName(func); +}; + +/** Find the first named child with the given node type */ +export const findChildByType = (node: SyntaxNode, type: string): SyntaxNode | null => { + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === type) return child; + } + return null; +}; + +// Internal helper: extract the first comma-separated argument from a string, +// respecting nested angle-bracket and square-bracket depth. +function extractFirstArg(args: string): string { + let depth = 0; + for (let i = 0; i < args.length; i++) { + const ch = args[i]; + if (ch === '<' || ch === '[') depth++; + else if (ch === '>' || ch === ']') depth--; + else if (ch === ',' && depth === 0) return args.slice(0, i).trim(); + } + return args.trim(); +} + +/** + * Extract element type from a container type string. + * Uses bracket-balanced parsing (no regex) for generic argument extraction. + * Returns undefined for ambiguous or unparseable strings. + * + * Handles: + * - Array<User> → User (generic angle brackets) + * - User[] → User (array suffix) + * - []User → User (Go slice prefix) + * - List[User] → User (Python subscript) + * - [User] → User (Swift array sugar) + * - vector<User> → User (C++ container) + * - Vec<User> → User (Rust container) + * + * For multi-argument generics (Map<K, V>), returns the first or last type arg + * based on `pos` ('first' for keys, 'last' for values — default 'last'). + * Returns undefined when the extracted type is not a simple word. + */ +export function extractElementTypeFromString(typeStr: string, pos: TypeArgPosition = 'last'): string | undefined { + if (!typeStr || typeStr.length === 0 || typeStr.length > 2048) return undefined; + + // 1. Array suffix: User[] → User + if (typeStr.endsWith('[]')) { + const base = typeStr.slice(0, -2).trim(); + return base && /^\w+$/.test(base) ? base : undefined; + } + + // 2. Go slice prefix: []User → User + if (typeStr.startsWith('[]')) { + const element = typeStr.slice(2).trim(); + return element && /^\w+$/.test(element) ? element : undefined; + } + + // 3. Swift array sugar: [User] → User + // Must start with '[', end with ']', and contain no angle brackets + // (to avoid confusing with List[User] handled below). + if (typeStr.startsWith('[') && typeStr.endsWith(']') && !typeStr.includes('<')) { + const element = typeStr.slice(1, -1).trim(); + return element && /^\w+$/.test(element) ? element : undefined; + } + + // 4. Generic bracket-balanced extraction: Array<User> / List[User] / Vec<User> + // Find the first opening bracket (< or [) and pick the one that appears first. + const openAngle = typeStr.indexOf('<'); + const openSquare = typeStr.indexOf('['); + + let openIdx = -1; + let openChar = ''; + let closeChar = ''; + + if (openAngle >= 0 && (openSquare < 0 || openAngle < openSquare)) { + openIdx = openAngle; + openChar = '<'; + closeChar = '>'; + } else if (openSquare >= 0) { + openIdx = openSquare; + openChar = '['; + closeChar = ']'; + } + + if (openIdx < 0) return undefined; + + // Walk bracket-balanced from the character after the opening bracket to find + // the matching close bracket, tracking depth for nested brackets. + // All bracket types (<, >, [, ]) contribute to depth uniformly, but only the + // selected closeChar can match at depth 0 (prevents cross-bracket miscounting). + let depth = 0; + const start = openIdx + 1; + let lastCommaIdx = -1; // Track last top-level comma for 'last' position + for (let i = start; i < typeStr.length; i++) { + const ch = typeStr[i]; + if (ch === '<' || ch === '[') { + depth++; + } else if (ch === '>' || ch === ']') { + if (depth === 0) { + // At depth 0 — only match if it is our selected close bracket. + if (ch !== closeChar) return undefined; // mismatched bracket = malformed + if (pos === 'last' && lastCommaIdx >= 0) { + // Return last arg (text after last comma) + const lastArg = typeStr.slice(lastCommaIdx + 1, i).trim(); + return lastArg && /^\w+$/.test(lastArg) ? lastArg : undefined; + } + const inner = typeStr.slice(start, i).trim(); + const firstArg = extractFirstArg(inner); + return firstArg && /^\w+$/.test(firstArg) ? firstArg : undefined; + } + depth--; + } else if (ch === ',' && depth === 0) { + if (pos === 'first') { + // Return first arg (text before first comma) + const arg = typeStr.slice(start, i).trim(); + return arg && /^\w+$/.test(arg) ? arg : undefined; + } + lastCommaIdx = i; + } + } + + return undefined; +} + +// ── Return type text helpers ───────────────────────────────────────────── +// extractReturnTypeName works on raw return-type text already stored in +// SymbolDefinition (e.g. "User", "Promise<User>", "User | null", "*User"). +// Extracts the base user-defined type name. + +/** Primitive / built-in types that should NOT produce a receiver binding. */ +const PRIMITIVE_TYPES = new Set([ + 'string', 'number', 'boolean', 'void', 'int', 'float', 'double', 'long', + 'short', 'byte', 'char', 'bool', 'str', 'i8', 'i16', 'i32', 'i64', + 'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'usize', 'isize', + 'undefined', 'null', 'None', 'nil', +]); + +/** + * Extract a simple type name from raw return-type text. + * Handles common patterns: + * "User" → "User" + * "Promise<User>" → "User" (unwrap wrapper generics) + * "Option<User>" → "User" + * "Result<User, Error>" → "User" (first type arg) + * "User | null" → "User" (strip nullable union) + * "User?" → "User" (strip nullable suffix) + * "*User" → "User" (Go pointer) + * "&User" → "User" (Rust reference) + * Returns undefined for complex types or primitives. + */ +const WRAPPER_GENERICS = new Set([ + 'Promise', 'Observable', 'Future', 'CompletableFuture', 'Task', 'ValueTask', // async wrappers + 'Option', 'Some', 'Optional', 'Maybe', // nullable wrappers + 'Result', 'Either', // result wrappers + // Rust smart pointers (Deref to inner type) + 'Rc', 'Arc', 'Weak', // pointer types + 'MutexGuard', 'RwLockReadGuard', 'RwLockWriteGuard', // guard types + 'Ref', 'RefMut', // RefCell guards + 'Cow', // copy-on-write + // Containers (List, Array, Vec, Set, etc.) are intentionally excluded — + // methods are called on the container, not the element type. + // Non-wrapper generics return the base type (e.g., List) via the else branch. +]); + +/** + * Extracts the first type argument from a comma-separated generic argument string, + * respecting nested angle brackets. For example: + * "Result<User, Error>" → "Result<User, Error>" (no top-level comma) + * "User, Error" → "User" + * "Map<K, V>, string" → "Map<K, V>" + */ +function extractFirstGenericArg(args: string): string { + let depth = 0; + for (let i = 0; i < args.length; i++) { + if (args[i] === '<') depth++; + else if (args[i] === '>') depth--; + else if (args[i] === ',' && depth === 0) return args.slice(0, i).trim(); + } + return args.trim(); +} + +/** + * Extract the first non-lifetime type argument from a generic argument string. + * Skips Rust lifetime parameters (e.g., `'a`, `'_`) to find the actual type. + * "'_, User" → "User" + * "'a, User" → "User" + * "User, Error" → "User" (no lifetime — delegates to extractFirstGenericArg) + */ +function extractFirstTypeArg(args: string): string { + let remaining = args; + while (remaining) { + const first = extractFirstGenericArg(remaining); + if (!first.startsWith("'")) return first; + // Skip past this lifetime arg + the comma separator + const commaIdx = remaining.indexOf(',', first.length); + if (commaIdx < 0) return first; // only lifetimes — fall through + remaining = remaining.slice(commaIdx + 1).trim(); + } + return args.trim(); +} + +const MAX_RETURN_TYPE_INPUT_LENGTH = 2048; +const MAX_RETURN_TYPE_LENGTH = 512; + +export const extractReturnTypeName = (raw: string, depth = 0): string | undefined => { + if (depth > 10) return undefined; + if (raw.length > MAX_RETURN_TYPE_INPUT_LENGTH) return undefined; + let text = raw.trim(); + if (!text) return undefined; + + // Strip pointer/reference prefixes: *User, &User, &mut User + text = text.replace(/^[&*]+\s*(mut\s+)?/, ''); + + // Strip nullable suffix: User? + text = text.replace(/\?$/, ''); + + // Handle union types: "User | null" → "User" + if (text.includes('|')) { + const parts = text.split('|').map(p => p.trim()).filter(p => + p !== 'null' && p !== 'undefined' && p !== 'void' && p !== 'None' && p !== 'nil' + ); + if (parts.length === 1) text = parts[0]; + else return undefined; // genuine union — too complex + } + + // Handle generics: Promise<User> → unwrap if wrapper, else take base + const genericMatch = text.match(/^(\w+)\s*<(.+)>$/); + if (genericMatch) { + const [, base, args] = genericMatch; + if (WRAPPER_GENERICS.has(base)) { + // Take the first non-lifetime type argument, using bracket-balanced splitting + // so that nested generics like Result<User, Error> are not split at the inner + // comma. Lifetime parameters (Rust 'a, '_) are skipped. + const firstArg = extractFirstTypeArg(args); + return extractReturnTypeName(firstArg, depth + 1); + } + // Non-wrapper generic: return the base type (e.g., Map<K,V> → Map) + return PRIMITIVE_TYPES.has(base.toLowerCase()) ? undefined : base; + } + + // Bare wrapper type without generic argument (e.g. Task, Promise, Option) + // should not produce a binding — these are meaningless without a type parameter + if (WRAPPER_GENERICS.has(text)) return undefined; + + // Handle qualified names: models.User → User, Models::User → User, \App\Models\User → User + if (text.includes('::') || text.includes('.') || text.includes('\\')) { + text = text.split(/::|[.\\]/).pop()!; + } + + // Final check: skip primitives + if (PRIMITIVE_TYPES.has(text) || PRIMITIVE_TYPES.has(text.toLowerCase())) return undefined; + + // Must start with uppercase (class/type convention) or be a valid identifier + if (!/^[A-Z_]\w*$/.test(text)) return undefined; + + // If the final extracted type name is too long, reject it + if (text.length > MAX_RETURN_TYPE_LENGTH) return undefined; + + return text; +}; + +// ── Property declared-type extraction ──────────────────────────────────── +// Shared between parse-worker (worker path) and parsing-processor (sequential path). + +/** + * Extract the declared type of a property/field from its AST definition node. + * Handles cross-language patterns: + * - TypeScript: `name: Type` → type_annotation child + * - Java: `Type name` → type child on field_declaration + * - C#: `Type Name { get; set; }` → type child on property_declaration + * - Go: `Name Type` → type child on field_declaration + * - Kotlin: `var name: Type` → variable_declaration child with type field + * + * Returns the normalized type name, or undefined if no type can be extracted. + */ +export const extractPropertyDeclaredType = (definitionNode: SyntaxNode | null): string | undefined => { + if (!definitionNode) return undefined; + + // Strategy 1: Look for a `type` or `type_annotation` named field + const typeNode = definitionNode.childForFieldName?.('type'); + if (typeNode) { + const typeName = extractSimpleTypeName(typeNode); + if (typeName) return typeName; + // Fallback: use the raw text (for complex types like User[] or List<User>) + const text = typeNode.text?.trim(); + if (text && text.length < 100) return text; + } + + // Strategy 2: Walk children looking for type_annotation (TypeScript pattern) + for (let i = 0; i < definitionNode.childCount; i++) { + const child = definitionNode.child(i); + if (!child) continue; + if (child.type === 'type_annotation') { + // Type annotation has the actual type as a child + for (let j = 0; j < child.childCount; j++) { + const typeChild = child.child(j); + if (typeChild && typeChild.type !== ':') { + const typeName = extractSimpleTypeName(typeChild); + if (typeName) return typeName; + const text = typeChild.text?.trim(); + if (text && text.length < 100) return text; + } + } + } + } + + // Strategy 3: For Java field_declaration, the type is a sibling of variable_declarator + // AST: (field_declaration type: (type_identifier) declarator: (variable_declarator ...)) + const parentDecl = definitionNode.parent; + if (parentDecl) { + const parentType = parentDecl.childForFieldName?.('type'); + if (parentType) { + const typeName = extractSimpleTypeName(parentType); + if (typeName) return typeName; + } + } + + // Strategy 4: Kotlin property_declaration — type is nested inside variable_declaration child + // AST: (property_declaration (variable_declaration (simple_identifier) ":" (user_type (type_identifier)))) + // Kotlin's variable_declaration has NO named 'type' field — children are all positional. + for (let i = 0; i < definitionNode.childCount; i++) { + const child = definitionNode.child(i); + if (child?.type === 'variable_declaration') { + // Try named field first (works for other languages sharing this strategy) + const varType = child.childForFieldName?.('type'); + if (varType) { + const typeName = extractSimpleTypeName(varType); + if (typeName) return typeName; + const text = varType.text?.trim(); + if (text && text.length < 100) return text; + } + // Fallback: walk unnamed children for user_type / type_identifier (Kotlin) + for (let j = 0; j < child.namedChildCount; j++) { + const varChild = child.namedChild(j); + if (varChild && (varChild.type === 'user_type' || varChild.type === 'type_identifier' + || varChild.type === 'nullable_type' || varChild.type === 'generic_type')) { + const typeName = extractSimpleTypeName(varChild); + if (typeName) return typeName; + } + } + } + } + + // Strategy 5: PHP @var PHPDoc — look for preceding comment with @var Type + // Handles pre-PHP-7.4 code: /** @var Address */ public $address; + const prevSibling = definitionNode.previousNamedSibling ?? definitionNode.parent?.previousNamedSibling; + if (prevSibling?.type === 'comment') { + const commentText = prevSibling.text; + const varMatch = commentText?.match(/@var\s+([A-Z][\w\\]*)/); + if (varMatch) { + // Strip namespace prefix: \App\Models\User → User + const raw = varMatch[1]; + const base = raw.includes('\\') ? raw.split('\\').pop()! : raw; + if (base && /^[A-Z]\w*$/.test(base)) return base; + } + } + + return undefined; +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/swift.ts b/gitnexus/src/core/ingestion/type-extractors/swift.ts new file mode 100644 index 0000000000..3d3dbe7297 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/swift.ts @@ -0,0 +1,127 @@ +import type { SyntaxNode } from '../utils.js'; +import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner } from './types.js'; +import { extractSimpleTypeName, extractVarName, findChildByType, hasTypeAnnotation } from './shared.js'; + +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'property_declaration', +]); + +/** Swift: let x: Foo = ... */ +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + // Swift property_declaration has pattern and type_annotation + const pattern = node.childForFieldName('pattern') + ?? findChildByType(node, 'pattern'); + const typeAnnotation = node.childForFieldName('type') + ?? findChildByType(node, 'type_annotation'); + if (!pattern || !typeAnnotation) return; + const varName = extractVarName(pattern) ?? pattern.text; + const typeName = extractSimpleTypeName(typeAnnotation); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Swift: parameter → name: type */ +const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'parameter') { + nameNode = node.childForFieldName('name') + ?? node.childForFieldName('internal_name'); + typeNode = node.childForFieldName('type'); + } else { + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** Swift: let user = User(name: "alice") — infer type from call when callee is a known class. + * Swift initializers are syntactically identical to function calls, so we verify + * against classNames (which may include cross-file SymbolTable lookups). */ +const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup): void => { + if (node.type !== 'property_declaration') return; + // Skip if has type annotation — extractDeclaration handled it + if (node.childForFieldName('type') || findChildByType(node, 'type_annotation')) return; + // Find pattern (variable name) + const pattern = node.childForFieldName('pattern') ?? findChildByType(node, 'pattern'); + if (!pattern) return; + const varName = extractVarName(pattern) ?? pattern.text; + if (!varName || env.has(varName)) return; + // Find call_expression in the value + const callExpr = findChildByType(node, 'call_expression'); + if (!callExpr) return; + const callee = callExpr.firstNamedChild; + if (!callee) return; + // Direct call: User(name: "alice") + if (callee.type === 'simple_identifier') { + const calleeName = callee.text; + if (calleeName && classNames.has(calleeName)) { + env.set(varName, calleeName); + } + return; + } + // Explicit init: User.init(name: "alice") — navigation_expression with .init suffix + if (callee.type === 'navigation_expression') { + const receiver = callee.firstNamedChild; + const suffix = callee.lastNamedChild; + if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') { + const calleeName = receiver.text; + if (calleeName && classNames.has(calleeName)) { + env.set(varName, calleeName); + } + } + } +}; + +/** Swift: let user = User(name: "alice") — scan property_declaration for constructor binding */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'property_declaration') return undefined; + if (hasTypeAnnotation(node)) return undefined; + const pattern = node.childForFieldName('pattern'); + if (!pattern) return undefined; + const varName = pattern.text; + if (!varName) return undefined; + let callExpr: SyntaxNode | null = null; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === 'call_expression') { callExpr = child; break; } + } + if (!callExpr) return undefined; + const callee = callExpr.firstNamedChild; + if (!callee) return undefined; + if (callee.type === 'simple_identifier') { + return { varName, calleeName: callee.text }; + } + if (callee.type === 'navigation_expression') { + const receiver = callee.firstNamedChild; + const suffix = callee.lastNamedChild; + if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') { + return { varName, calleeName: receiver.text }; + } + // General qualified call: service.getUser() → extract method name. + // tree-sitter-swift may wrap the identifier in navigation_suffix, so + // check both direct simple_identifier and navigation_suffix > simple_identifier. + if (suffix?.type === 'simple_identifier') { + return { varName, calleeName: suffix.text }; + } + if (suffix?.type === 'navigation_suffix') { + const inner = suffix.lastNamedChild; + if (inner?.type === 'simple_identifier') { + return { varName, calleeName: inner.text }; + } + } + } + return undefined; +}; + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + extractDeclaration, + extractParameter, + extractInitializer, + scanConstructorBinding, +}; diff --git a/gitnexus/src/core/ingestion/type-extractors/types.ts b/gitnexus/src/core/ingestion/type-extractors/types.ts new file mode 100644 index 0000000000..5896af1492 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/types.ts @@ -0,0 +1,133 @@ +import type { SyntaxNode } from '../utils.js'; + +/** Extracts type bindings from a declaration node into the env map */ +export type TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>) => void; + +/** Extracts type bindings from a parameter node into the env map */ +export type ParameterExtractor = (node: SyntaxNode, env: Map<string, string>) => void; + +/** Minimal interface for checking whether a name is a known class/struct. + * Narrower than ReadonlySet — only `.has()` is used by extractors. */ +export type ClassNameLookup = { has(name: string): boolean }; + +/** Extracts type bindings from a constructor-call initializer, with access to known class names */ +export type InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup) => void; + +/** Scans an AST node for untyped `var = callee()` patterns for return-type inference. + * Returns { varName, calleeName } if the node matches, undefined otherwise. + * `receiverClassName` — optional hint for method calls on known receivers + * (e.g. $this->getUser() in PHP provides the enclosing class name). */ +export type ConstructorBindingScanner = (node: SyntaxNode) => { varName: string; calleeName: string; receiverClassName?: string } | undefined; + +/** Extracts a return type string from a method/function definition node. + * Used for languages where return types are expressed in comments (e.g. YARD @return [Type]) + * rather than in AST fields. Returns undefined if no return type can be determined. */ +export type ReturnTypeExtractor = (node: SyntaxNode) => string | undefined; + +/** Narrow lookup interface for resolving a callee name → return type name. + * Backed by SymbolTable.lookupFuzzyCallable; passed via ForLoopExtractorContext. + * Conservative: returns undefined when the callee is ambiguous (0 or 2+ matches). */ +export interface ReturnTypeLookup { + /** Processed type name after stripping wrappers (e.g., 'User' from 'Promise<User>'). + * Use for call-result variable bindings (`const b = foo()`). */ + lookupReturnType(callee: string): string | undefined; + /** Raw return type as declared in the symbol (e.g., '[]User', 'List<User>'). + * Use for iterable-element extraction (`for v := range foo()`). */ + lookupRawReturnType(callee: string): string | undefined; +} + +/** Context object passed to ForLoopExtractor. + * Groups the four parameters that were previously positional. */ +export interface ForLoopExtractorContext { + /** Mutable type-env for the current scope — extractor writes bindings here */ + scopeEnv: Map<string, string>; + /** Maps `scope\0varName` to the declaration's type annotation AST node */ + declarationTypeNodes: ReadonlyMap<string, SyntaxNode>; + /** Current scope key, e.g. `"process@42"` */ + scope: string; + /** Resolves a callee name to its declared return type (undefined = unknown/ambiguous) */ + returnTypeLookup: ReturnTypeLookup; +} + +/** Extracts loop variable type binding from a for-each statement. */ +export type ForLoopExtractor = (node: SyntaxNode, ctx: ForLoopExtractorContext) => void; + +/** Discriminated union for pending Tier-2 propagation items. + * - `copy` — `const b = a` (identifier alias, propagate a's type to b) + * - `callResult` — `const b = foo()` (bind b to foo's declared return type) */ +export type PendingAssignment = + | { kind: 'copy'; lhs: string; rhs: string } + | { kind: 'callResult'; lhs: string; callee: string }; + +/** Extracts a pending assignment for Tier 2 propagation. + * Returns a PendingAssignment when the RHS is a bare identifier (`copy`) or a + * call expression (`callResult`) and the LHS has no resolved type yet. + * Returns undefined if the node is not a matching assignment. */ +export type PendingAssignmentExtractor = ( + node: SyntaxNode, + scopeEnv: ReadonlyMap<string, string>, +) => PendingAssignment | undefined; + +/** Extracts a typed variable binding from a pattern-matching construct. + * Returns { varName, typeName } for patterns that introduce NEW variables. + * Examples: `if let Some(user) = opt` (Rust), `x instanceof User user` (Java). + * Conservative: returns undefined when the source variable's type is unknown. + * + * @param scopeEnv Read-only view of already-resolved type bindings in the current scope. + * @param declarationTypeNodes Maps `scope\0varName` to the original declaration's type + * annotation AST node. Allows extracting generic type arguments (e.g., T from Result<T,E>) + * that are stripped during normal TypeEnv extraction. + * @param scope Current scope key (e.g. `"process@42"`) for declarationTypeNodes lookups. */ +export type PatternBindingExtractor = ( + node: SyntaxNode, + scopeEnv: ReadonlyMap<string, string>, + declarationTypeNodes: ReadonlyMap<string, SyntaxNode>, + scope: string, +) => { varName: string; typeName: string } | undefined; + +/** Per-language type extraction configuration */ +export interface LanguageTypeConfig { + /** Allow pattern binding to overwrite existing scopeEnv entries. + * WARNING: Enables function-scope type pollution. Only for languages with + * smart-cast semantics (e.g., Kotlin `when/is`) where the subject variable + * already exists in scopeEnv from its declaration. */ + readonly allowPatternBindingOverwrite?: boolean; + /** Node types that represent typed declarations for this language */ + declarationNodeTypes: ReadonlySet<string>; + /** AST node types for for-each/for-in statements with explicit element types. */ + forLoopNodeTypes?: ReadonlySet<string>; + /** Optional allowlist of AST node types on which extractPatternBinding should run. + * When present, extractPatternBinding is only invoked for nodes whose type is in this set, + * short-circuiting the call for all other node types. When absent, every node is passed to + * extractPatternBinding (legacy behaviour). */ + patternBindingNodeTypes?: ReadonlySet<string>; + /** Extract a (varName → typeName) binding from a declaration node */ + extractDeclaration: TypeBindingExtractor; + /** Extract a (varName → typeName) binding from a parameter node */ + extractParameter: ParameterExtractor; + /** Extract a (varName → typeName) binding from a constructor-call initializer. + * Called as fallback when extractDeclaration produces no binding for a declaration node. + * Only for languages with syntactic constructor markers (new, composite_literal, ::new). + * Receives classNames — the set of class/struct names visible in the current file's AST. */ + extractInitializer?: InitializerExtractor; + /** Scan for untyped `var = callee()` assignments for return-type inference. + * Called on every AST node during buildTypeEnv walk; returns undefined for non-matches. + * The callee binding is unverified — the caller must confirm against the SymbolTable. */ + scanConstructorBinding?: ConstructorBindingScanner; + /** Extract return type from comment-based annotations (e.g. YARD @return [Type]). + * Called as fallback when extractMethodSignature finds no AST-based return type. */ + extractReturnType?: ReturnTypeExtractor; + /** Extract loop variable → type binding from a for-each AST node. */ + extractForLoopBinding?: ForLoopExtractor; + /** Extract pending assignment for Tier 2 propagation. + * Called on declaration/assignment nodes; returns a PendingAssignment when the RHS + * is a bare identifier (copy) or call expression (callResult) and the LHS has no + * resolved type yet. Language-specific because AST shapes differ widely. */ + extractPendingAssignment?: PendingAssignmentExtractor; + /** Extract a typed variable binding from a pattern-matching construct. + * Called on every AST node; returns { varName, typeName } when the node introduces a new + * typed variable via pattern matching (e.g. `if let Some(x) = opt`, `x instanceof T t`). + * The extractor receives the current scope's resolved bindings (read-only) to look up the + * source variable's type. Returns undefined for non-matching nodes or unknown source types. */ + extractPatternBinding?: PatternBindingExtractor; +} diff --git a/gitnexus/src/core/ingestion/type-extractors/typescript.ts b/gitnexus/src/core/ingestion/type-extractors/typescript.ts new file mode 100644 index 0000000000..8f215203d6 --- /dev/null +++ b/gitnexus/src/core/ingestion/type-extractors/typescript.ts @@ -0,0 +1,474 @@ +import type { SyntaxNode } from '../utils.js'; +import type { LanguageTypeConfig, ParameterExtractor, TypeBindingExtractor, InitializerExtractor, ClassNameLookup, ConstructorBindingScanner, ReturnTypeExtractor, PendingAssignmentExtractor, ForLoopExtractor, PatternBindingExtractor } from './types.js'; +import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractCalleeName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, type TypeArgPosition } from './shared.js'; + +const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set([ + 'lexical_declaration', + 'variable_declaration', + 'function_declaration', // JSDoc @param on function declarations + 'method_definition', // JSDoc @param on class methods + 'public_field_definition', // class field: private users: User[] +]); + +const normalizeJsDocType = (raw: string): string | undefined => { + let type = raw.trim(); + // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User + if (type.startsWith('?') || type.startsWith('!')) type = type.slice(1); + // Strip union with null/undefined/void: User|null → User + const parts = type.split('|').map(p => p.trim()).filter(p => + p !== 'null' && p !== 'undefined' && p !== 'void' + ); + if (parts.length !== 1) return undefined; // ambiguous union + type = parts[0]; + // Strip module: prefix — module:models.User → models.User + if (type.startsWith('module:')) type = type.slice(7); + // Take last segment of dotted path: models.User → User + const segments = type.split('.'); + type = segments[segments.length - 1]; + // Strip generic wrapper: Promise<User> → Promise (base type, not inner) + const genericMatch = type.match(/^(\w+)\s*</); + if (genericMatch) type = genericMatch[1]; + // Simple identifier check + if (/^\w+$/.test(type)) return type; + return undefined; +}; + +/** Regex to extract JSDoc @param annotations: `@param {Type} name` */ +const JSDOC_PARAM_RE = /@param\s*\{([^}]+)\}\s+\[?(\w+)[\]=]?[^\s]*/g; + +/** + * Collect JSDoc @param type bindings from comment nodes preceding a function/method. + * Returns a map of paramName → typeName. + */ +const collectJsDocParams = (funcNode: SyntaxNode): Map<string, string> => { + const commentTexts: string[] = []; + let sibling = funcNode.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + commentTexts.unshift(sibling.text); + } else if (sibling.isNamed && sibling.type !== 'decorator') { + break; + } + sibling = sibling.previousSibling; + } + if (commentTexts.length === 0) return new Map(); + + const params = new Map<string, string>(); + const commentBlock = commentTexts.join('\n'); + JSDOC_PARAM_RE.lastIndex = 0; + let match: RegExpExecArray | null; + while ((match = JSDOC_PARAM_RE.exec(commentBlock)) !== null) { + const typeName = normalizeJsDocType(match[1]); + const paramName = match[2]; + if (typeName) { + params.set(paramName, typeName); + } + } + return params; +}; + +/** + * TypeScript: const x: Foo = ..., let x: Foo + * Also: JSDoc @param annotations on function/method definitions (for .js files). + */ +const extractDeclaration: TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + // JSDoc @param on functions/methods — pre-populate env with param types + if (node.type === 'function_declaration' || node.type === 'method_definition') { + const jsDocParams = collectJsDocParams(node); + for (const [paramName, typeName] of jsDocParams) { + if (!env.has(paramName)) env.set(paramName, typeName); + } + return; + } + + // Class field: `private users: User[]` — public_field_definition has name + type fields directly. + if (node.type === 'public_field_definition') { + const nameNode = node.childForFieldName('name'); + const typeAnnotation = node.childForFieldName('type'); + if (!nameNode || !typeAnnotation) return; + const varName = nameNode.text; + if (!varName) return; + const typeName = extractSimpleTypeName(typeAnnotation); + if (typeName) env.set(varName, typeName); + return; + } + + for (let i = 0; i < node.namedChildCount; i++) { + const declarator = node.namedChild(i); + if (declarator?.type !== 'variable_declarator') continue; + const nameNode = declarator.childForFieldName('name'); + const typeAnnotation = declarator.childForFieldName('type'); + if (!nameNode || !typeAnnotation) continue; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeAnnotation); + if (varName && typeName) env.set(varName, typeName); + } +}; + +/** TypeScript: required_parameter / optional_parameter → name: type */ +const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => { + let nameNode: SyntaxNode | null = null; + let typeNode: SyntaxNode | null = null; + + if (node.type === 'required_parameter' || node.type === 'optional_parameter') { + nameNode = node.childForFieldName('pattern') ?? node.childForFieldName('name'); + typeNode = node.childForFieldName('type'); + } else { + // Generic fallback + nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern'); + typeNode = node.childForFieldName('type'); + } + + if (!nameNode || !typeNode) return; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(typeNode); + if (varName && typeName) env.set(varName, typeName); +}; + +/** TypeScript: const x = new User() — infer type from new_expression */ +const extractInitializer: InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, _classNames: ClassNameLookup): void => { + for (let i = 0; i < node.namedChildCount; i++) { + const declarator = node.namedChild(i); + if (declarator?.type !== 'variable_declarator') continue; + // Only activate when there is no explicit type annotation — extractDeclaration already + // handles the annotated case and this function is called as a fallback. + if (declarator.childForFieldName('type') !== null) continue; + let valueNode = declarator.childForFieldName('value'); + // Unwrap `new User() as T`, `new User()!`, and double-cast `new User() as unknown as T` + while (valueNode?.type === 'as_expression' || valueNode?.type === 'non_null_expression') { + valueNode = valueNode.firstNamedChild; + } + if (valueNode?.type !== 'new_expression') continue; + const constructorNode = valueNode.childForFieldName('constructor'); + if (!constructorNode) continue; + const nameNode = declarator.childForFieldName('name'); + if (!nameNode) continue; + const varName = extractVarName(nameNode); + const typeName = extractSimpleTypeName(constructorNode); + if (varName && typeName) env.set(varName, typeName); + } +}; + +/** + * TypeScript/JavaScript: const user = getUser() — variable_declarator with call_expression value. + * Only matches unannotated declarators; annotated ones are handled by extractDeclaration. + * await is unwrapped: const user = await fetchUser() → callee = 'fetchUser'. + */ +const scanConstructorBinding: ConstructorBindingScanner = (node) => { + if (node.type !== 'variable_declarator') return undefined; + if (hasTypeAnnotation(node)) return undefined; + const nameNode = node.childForFieldName('name'); + if (!nameNode || nameNode.type !== 'identifier') return undefined; + const value = unwrapAwait(node.childForFieldName('value')); + if (!value || value.type !== 'call_expression') return undefined; + const calleeName = extractCalleeName(value); + if (!calleeName) return undefined; + return { varName: nameNode.text, calleeName }; +}; + +/** Regex to extract @returns or @return from JSDoc comments: `@returns {Type}` */ +const JSDOC_RETURN_RE = /@returns?\s*\{([^}]+)\}/; + +/** + * Minimal sanitization for JSDoc return types — preserves generic wrappers + * (e.g. `Promise<User>`) so that extractReturnTypeName in call-processor + * can apply WRAPPER_GENERICS unwrapping. Unlike normalizeJsDocType (which + * strips generics), this only strips JSDoc-specific syntax markers. + */ +const sanitizeReturnType = (raw: string): string | undefined => { + let type = raw.trim(); + // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User + if (type.startsWith('?') || type.startsWith('!')) type = type.slice(1); + // Strip module: prefix — module:models.User → models.User + if (type.startsWith('module:')) type = type.slice(7); + // Reject unions (ambiguous) + if (type.includes('|')) return undefined; + if (!type) return undefined; + return type; +}; + +/** + * Extract return type from JSDoc `@returns {Type}` or `@return {Type}` annotation + * preceding a function/method definition. Walks backwards through preceding siblings + * looking for comment nodes containing the annotation. + */ +const extractReturnType: ReturnTypeExtractor = (node) => { + let sibling = node.previousSibling; + while (sibling) { + if (sibling.type === 'comment') { + const match = JSDOC_RETURN_RE.exec(sibling.text); + if (match) return sanitizeReturnType(match[1]); + } else if (sibling.isNamed && sibling.type !== 'decorator') break; + sibling = sibling.previousSibling; + } + return undefined; +}; + +const FOR_LOOP_NODE_TYPES: ReadonlySet<string> = new Set([ + 'for_in_statement', +]); + +/** TS function/method node types that carry a parameters list. */ +const TS_FUNCTION_NODE_TYPES = new Set([ + 'function_declaration', 'function_expression', 'arrow_function', + 'method_definition', 'generator_function', 'generator_function_declaration', +]); + +/** + * Extract element type from a TypeScript type annotation AST node. + * Handles: + * type_annotation ": User[]" → array_type → type_identifier "User" + * type_annotation ": Array<User>" → generic_type → extractGenericTypeArgs → "User" + * Falls back to text-based extraction via extractElementTypeFromString. + */ +const extractTsElementTypeFromAnnotation = (typeAnnotation: SyntaxNode, pos: TypeArgPosition = 'last', depth = 0): string | undefined => { + if (depth > 50) return undefined; + // Unwrap type_annotation (the node text includes ': ' prefix) + const inner = typeAnnotation.type === 'type_annotation' + ? (typeAnnotation.firstNamedChild ?? typeAnnotation) + : typeAnnotation; + + // readonly User[] — readonly_type wraps array_type: unwrap and recurse + if (inner.type === 'readonly_type') { + const wrapped = inner.firstNamedChild; + if (wrapped) return extractTsElementTypeFromAnnotation(wrapped, pos, depth + 1); + } + + // User[] — array_type: first named child is the element type + if (inner.type === 'array_type') { + const elem = inner.firstNamedChild; + if (elem) return extractSimpleTypeName(elem); + } + + // Array<User>, Map<string, User> — generic_type + // pos determines which type arg: 'first' for keys, 'last' for values + if (inner.type === 'generic_type') { + const args = extractGenericTypeArgs(inner); + if (args.length >= 1) return pos === 'first' ? args[0] : args[args.length - 1]; + } + + // Fallback: strip ': ' prefix from type_annotation text and use string extraction + const rawText = inner.text; + return extractElementTypeFromString(rawText, pos); +}; + +/** + * Search a statement_block (function body) for a variable_declarator named `iterableName` + * that has a type annotation, preceding the given `beforeNode`. + * Returns the element type from the type annotation, or undefined. + */ +const findTsLocalDeclElementType = ( + iterableName: string, + blockNode: SyntaxNode, + beforeNode: SyntaxNode, + pos: TypeArgPosition = 'last', +): string | undefined => { + for (let i = 0; i < blockNode.namedChildCount; i++) { + const stmt = blockNode.namedChild(i); + if (!stmt) continue; + // Stop when we reach the for-loop itself + if (stmt === beforeNode || stmt.startIndex >= beforeNode.startIndex) break; + // Look for lexical_declaration or variable_declaration + if (stmt.type !== 'lexical_declaration' && stmt.type !== 'variable_declaration') continue; + for (let j = 0; j < stmt.namedChildCount; j++) { + const decl = stmt.namedChild(j); + if (decl?.type !== 'variable_declarator') continue; + const nameNode = decl.childForFieldName('name'); + if (nameNode?.text !== iterableName) continue; + const typeAnnotation = decl.childForFieldName('type'); + if (typeAnnotation) return extractTsElementTypeFromAnnotation(typeAnnotation, pos); + } + } + return undefined; +}; + +/** + * Walk up the AST from a for-loop node to find the enclosing function scope, + * then search (1) its parameter list and (2) local declarations in the body + * for a variable named `iterableName` with a container type annotation. + * Returns the element type extracted from the annotation, or undefined. + */ +const findTsIterableElementType = (iterableName: string, startNode: SyntaxNode, pos: TypeArgPosition = 'last'): string | undefined => { + let current: SyntaxNode | null = startNode.parent; + // Capture the immediate statement_block parent to search local declarations + const blockNode = current?.type === 'statement_block' ? current : null; + + while (current) { + if (TS_FUNCTION_NODE_TYPES.has(current.type)) { + // Search function parameters + const paramsNode = current.childForFieldName('parameters') + ?? current.childForFieldName('formal_parameters'); + if (paramsNode) { + for (let i = 0; i < paramsNode.namedChildCount; i++) { + const param = paramsNode.namedChild(i); + if (!param) continue; + const patternNode = param.childForFieldName('pattern') ?? param.childForFieldName('name'); + if (patternNode?.text === iterableName) { + const typeAnnotation = param.childForFieldName('type'); + if (typeAnnotation) return extractTsElementTypeFromAnnotation(typeAnnotation, pos); + } + } + } + // Search local declarations in the function body (statement_block) + if (blockNode) { + const result = findTsLocalDeclElementType(iterableName, blockNode, startNode, pos); + if (result) return result; + } + break; // stop at the nearest function boundary + } + current = current.parent; + } + return undefined; +}; + +/** + * TypeScript/JavaScript: for (const user of users) where users has a known array type. + * + * Both `for...of` and `for...in` use the same `for_in_statement` AST node in tree-sitter. + * We differentiate by checking for the `of` keyword among the unnamed children. + * + * Tier 1c: resolves the element type via three strategies in priority order: + * 1. declarationTypeNodes — raw type annotation AST node (covers Array<User> from declarations) + * 2. scopeEnv string — extractElementTypeFromString on the stored type (covers locally annotated vars) + * 3. AST walk — walks up to the enclosing function's parameters to read User[] annotations directly + * Only handles `for...of`; `for...in` produces string keys, not element types. + */ +const extractForLoopBinding: ForLoopExtractor = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }): void => { + if (node.type !== 'for_in_statement') return; + + // Confirm this is `for...of`, not `for...in`, by scanning unnamed children for the keyword text. + let isForOf = false; + for (let i = 0; i < node.childCount; i++) { + const child = node.child(i); + if (child && !child.isNamed && child.text === 'of') { + isForOf = true; + break; + } + } + if (!isForOf) return; + + // The iterable is the `right` field — may be identifier, member_expression, or call_expression. + const rightNode = node.childForFieldName('right'); + let iterableName: string | undefined; + let methodName: string | undefined; + let callExprElementType: string | undefined; + if (rightNode?.type === 'identifier') { + iterableName = rightNode.text; + } else if (rightNode?.type === 'member_expression') { + const prop = rightNode.childForFieldName('property'); + if (prop) iterableName = prop.text; + } else if (rightNode?.type === 'call_expression') { + // entries.values() → call_expression > function: member_expression > object + property + // this.repos.values() → nested member_expression: extract property from inner member + // getUsers() → call_expression > function: identifier (Phase 7.3 — return-type path) + const fn = rightNode.childForFieldName('function'); + if (fn?.type === 'member_expression') { + const obj = fn.childForFieldName('object'); + const prop = fn.childForFieldName('property'); + if (obj?.type === 'identifier') { + iterableName = obj.text; + } else if (obj?.type === 'member_expression') { + // this.repos.values() → obj = this.repos → extract 'repos' + const innerProp = obj.childForFieldName('property'); + if (innerProp) iterableName = innerProp.text; + } + if (prop?.type === 'property_identifier') methodName = prop.text; + } else if (fn?.type === 'identifier') { + // Direct function call: for (const user of getUsers()) + const rawReturn = returnTypeLookup.lookupRawReturnType(fn.text); + if (rawReturn) callExprElementType = extractElementTypeFromString(rawReturn); + } + } + if (!iterableName && !callExprElementType) return; + + let elementType: string | undefined; + if (callExprElementType) { + elementType = callExprElementType; + } else { + // Look up the container's base type name for descriptor-aware resolution + const containerTypeName = scopeEnv.get(iterableName!); + const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName); + elementType = resolveIterableElementType( + iterableName!, node, scopeEnv, declarationTypeNodes, scope, + extractTsElementTypeFromAnnotation, findTsIterableElementType, + typeArgPos, + ); + } + if (!elementType) return; + + // The loop variable is the `left` field. + const leftNode = node.childForFieldName('left'); + if (!leftNode) return; + + // Handle destructured for-of: for (const [k, v] of entries) + // AST: left = array_pattern directly (no variable_declarator wrapper) + // Bind the LAST identifier to the element type (value in [key, value] patterns) + if (leftNode.type === 'array_pattern') { + const lastChild = leftNode.lastNamedChild; + if (lastChild?.type === 'identifier') { + scopeEnv.set(lastChild.text, elementType); + } + return; + } + + if (leftNode.type === 'object_pattern') { + // Object destructuring (e.g., `for (const { id } of users)`) destructures + // into fields of the element type. Without field-level resolution, we cannot + // bind individual properties to their correct types. Skip to avoid false bindings. + return; + } + + let loopVarNode: SyntaxNode | null = leftNode; + // `const user` parses as: left → variable_declarator containing an identifier named `user` + if (loopVarNode.type === 'variable_declarator') { + loopVarNode = loopVarNode.childForFieldName('name') ?? loopVarNode.firstNamedChild; + } + if (!loopVarNode) return; + + const loopVarName = extractVarName(loopVarNode); + if (loopVarName) scopeEnv.set(loopVarName, elementType); +}; + +/** TS/JS: const alias = u → variable_declarator with name/value fields */ +const extractPendingAssignment: PendingAssignmentExtractor = (node, scopeEnv) => { + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (!child || child.type !== 'variable_declarator') continue; + const nameNode = child.childForFieldName('name'); + const valueNode = child.childForFieldName('value'); + if (!nameNode || !valueNode) continue; + const lhs = nameNode.text; + if (scopeEnv.has(lhs)) continue; + if (valueNode.type === 'identifier') return { kind: 'copy', lhs, rhs: valueNode.text }; + } + return undefined; +}; + +/** TS instanceof narrowing: `x instanceof User` → bind x to User. + * Only works when x has no prior type binding (e.g. x: unknown, untyped params). + * Typed params (x: Animal) are blocked by the !scopeEnv.has() guard in buildTypeEnv. + * Uses first-writer-wins, same as Rust match arm bindings. */ +const extractPatternBinding: PatternBindingExtractor = (node) => { + if (node.type !== 'binary_expression') return undefined; + const op = node.children.find(c => !c.isNamed && c.text === 'instanceof'); + if (!op) return undefined; + // binary_expression children are positional — no left/right fields + const left = node.namedChild(0); + const right = node.namedChild(1); + if (left?.type !== 'identifier' || right?.type !== 'identifier') return undefined; + return { varName: left.text, typeName: right.text }; +}; + +export const typeConfig: LanguageTypeConfig = { + declarationNodeTypes: DECLARATION_NODE_TYPES, + forLoopNodeTypes: FOR_LOOP_NODE_TYPES, + patternBindingNodeTypes: new Set(['binary_expression']), + extractDeclaration, + extractParameter, + extractInitializer, + scanConstructorBinding, + extractReturnType, + extractForLoopBinding, + extractPendingAssignment, + extractPatternBinding, +}; diff --git a/gitnexus/src/core/ingestion/utils.ts b/gitnexus/src/core/ingestion/utils.ts index 620fac7acd..da411cad4c 100644 --- a/gitnexus/src/core/ingestion/utils.ts +++ b/gitnexus/src/core/ingestion/utils.ts @@ -1,4 +1,526 @@ +import type Parser from 'tree-sitter'; import { SupportedLanguages } from '../../config/supported-languages.js'; +import { generateId } from '../../lib/utils.js'; + +/** Tree-sitter AST node. Re-exported for use across ingestion modules. */ +export type SyntaxNode = Parser.SyntaxNode; + +/** + * Ordered list of definition capture keys for tree-sitter query matches. + * Used to extract the definition node from a capture map. + */ +export const DEFINITION_CAPTURE_KEYS = [ + 'definition.function', + 'definition.class', + 'definition.interface', + 'definition.method', + 'definition.struct', + 'definition.enum', + 'definition.namespace', + 'definition.module', + 'definition.trait', + 'definition.impl', + 'definition.type', + 'definition.const', + 'definition.static', + 'definition.typedef', + 'definition.macro', + 'definition.union', + 'definition.property', + 'definition.record', + 'definition.delegate', + 'definition.annotation', + 'definition.constructor', + 'definition.template', +] as const; + +/** Extract the definition node from a tree-sitter query capture map. */ +export const getDefinitionNodeFromCaptures = (captureMap: Record<string, any>): SyntaxNode | null => { + for (const key of DEFINITION_CAPTURE_KEYS) { + if (captureMap[key]) return captureMap[key]; + } + return null; +}; + +/** + * Node types that represent function/method definitions across languages. + * Used to find the enclosing function for a call site. + */ +export const FUNCTION_NODE_TYPES = new Set([ + // TypeScript/JavaScript + 'function_declaration', + 'arrow_function', + 'function_expression', + 'method_definition', + 'generator_function_declaration', + // Python + 'function_definition', + // Common async variants + 'async_function_declaration', + 'async_arrow_function', + // Java + 'method_declaration', + 'constructor_declaration', + // C/C++ + // 'function_definition' already included above + // Go + // 'method_declaration' already included from Java + // C# + 'local_function_statement', + // Rust + 'function_item', + 'impl_item', // Methods inside impl blocks + // PHP + 'anonymous_function', + // Kotlin + 'lambda_literal', + // Swift + 'init_declaration', + 'deinit_declaration', + // Ruby + 'method', // def foo + 'singleton_method', // def self.foo +]); + +/** + * Node types for standard function declarations that need C/C++ declarator handling. + * Used by extractFunctionName to determine how to extract the function name. + */ +export const FUNCTION_DECLARATION_TYPES = new Set([ + 'function_declaration', + 'function_definition', + 'async_function_declaration', + 'generator_function_declaration', + 'function_item', +]); + +/** + * Built-in function/method names that should not be tracked as call targets. + * Covers JS/TS, Python, Kotlin, C/C++, PHP, Swift standard library functions. + */ +export const BUILT_IN_NAMES = new Set([ + // JavaScript/TypeScript + 'console', 'log', 'warn', 'error', 'info', 'debug', + 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', + 'parseInt', 'parseFloat', 'isNaN', 'isFinite', + 'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent', + 'JSON', 'parse', 'stringify', + 'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt', + 'Map', 'Set', 'WeakMap', 'WeakSet', + 'Promise', 'resolve', 'reject', 'then', 'catch', 'finally', + 'Math', 'Date', 'RegExp', 'Error', + 'require', 'import', 'export', 'fetch', 'Response', 'Request', + 'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext', + 'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue', + 'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy', + 'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every', + 'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split', + 'push', 'pop', 'shift', 'unshift', 'sort', 'reverse', + 'keys', 'values', 'entries', 'assign', 'freeze', 'seal', + 'hasOwnProperty', 'toString', 'valueOf', + // Python + 'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple', + 'append', 'extend', 'update', + // NOTE: 'open', 'read', 'write', 'close' removed — these are real C POSIX syscalls + 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr', + 'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs', + // Kotlin stdlib + 'println', 'print', 'readLine', 'require', 'requireNotNull', 'check', 'assert', 'lazy', 'error', + 'listOf', 'mapOf', 'setOf', 'mutableListOf', 'mutableMapOf', 'mutableSetOf', + 'arrayOf', 'sequenceOf', 'also', 'apply', 'run', 'with', 'takeIf', 'takeUnless', + 'TODO', 'buildString', 'buildList', 'buildMap', 'buildSet', + 'repeat', 'synchronized', + // Kotlin coroutine builders & scope functions + 'launch', 'async', 'runBlocking', 'withContext', 'coroutineScope', + 'supervisorScope', 'delay', + // Kotlin Flow operators + 'flow', 'flowOf', 'collect', 'emit', 'onEach', 'catch', + 'buffer', 'conflate', 'distinctUntilChanged', + 'flatMapLatest', 'flatMapMerge', 'combine', + 'stateIn', 'shareIn', 'launchIn', + // Kotlin infix stdlib functions + 'to', 'until', 'downTo', 'step', + // C/C++ standard library + 'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf', + 'scanf', 'fscanf', 'sscanf', + 'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp', + 'strlen', 'strcpy', 'strncpy', 'strcat', 'strncat', 'strcmp', 'strncmp', 'strstr', 'strchr', 'strrchr', + 'atoi', 'atol', 'atof', 'strtol', 'strtoul', 'strtoll', 'strtoull', 'strtod', + 'sizeof', 'offsetof', 'typeof', + 'assert', 'abort', 'exit', '_exit', + 'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs', + // Linux kernel common macros/helpers (not real call targets) + 'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE', + 'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL', + 'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe', + 'min', 'max', 'clamp', 'abs', 'swap', + 'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg', + 'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg', + 'GFP_KERNEL', 'GFP_ATOMIC', + 'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore', + 'mutex_lock', 'mutex_unlock', 'mutex_init', + 'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree', + 'get', 'put', + // C# / .NET built-ins + 'Console', 'WriteLine', 'ReadLine', 'Write', + 'Task', 'Run', 'Wait', 'WhenAll', 'WhenAny', 'FromResult', 'Delay', 'ContinueWith', + 'ConfigureAwait', 'GetAwaiter', 'GetResult', + 'ToString', 'GetType', 'Equals', 'GetHashCode', 'ReferenceEquals', + 'Add', 'Remove', 'Contains', 'Clear', 'Count', 'Any', 'All', + 'Where', 'Select', 'SelectMany', 'OrderBy', 'OrderByDescending', 'GroupBy', + 'First', 'FirstOrDefault', 'Single', 'SingleOrDefault', 'Last', 'LastOrDefault', + 'ToList', 'ToArray', 'ToDictionary', 'AsEnumerable', 'AsQueryable', + 'Aggregate', 'Sum', 'Average', 'Min', 'Max', 'Distinct', 'Skip', 'Take', + 'String', 'Format', 'IsNullOrEmpty', 'IsNullOrWhiteSpace', 'Concat', 'Join', + 'Trim', 'TrimStart', 'TrimEnd', 'Split', 'Replace', 'StartsWith', 'EndsWith', + 'Convert', 'ToInt32', 'ToDouble', 'ToBoolean', 'ToByte', + 'Math', 'Abs', 'Ceiling', 'Floor', 'Round', 'Pow', 'Sqrt', + 'Dispose', 'Close', + 'TryParse', 'Parse', + 'AddRange', 'RemoveAt', 'RemoveAll', 'FindAll', 'Exists', 'TrueForAll', + 'ContainsKey', 'TryGetValue', 'AddOrUpdate', + 'Throw', 'ThrowIfNull', + // PHP built-ins + 'echo', 'isset', 'empty', 'unset', 'list', 'array', 'compact', 'extract', + 'count', 'strlen', 'strpos', 'strrpos', 'substr', 'strtolower', 'strtoupper', 'trim', + 'ltrim', 'rtrim', 'str_replace', 'str_contains', 'str_starts_with', 'str_ends_with', + 'sprintf', 'vsprintf', 'printf', 'number_format', + 'array_map', 'array_filter', 'array_reduce', 'array_push', 'array_pop', 'array_shift', + 'array_unshift', 'array_slice', 'array_splice', 'array_merge', 'array_keys', 'array_values', + 'array_key_exists', 'in_array', 'array_search', 'array_unique', 'usort', 'rsort', + 'json_encode', 'json_decode', 'serialize', 'unserialize', + 'intval', 'floatval', 'strval', 'boolval', 'is_null', 'is_string', 'is_int', 'is_array', + 'is_object', 'is_numeric', 'is_bool', 'is_float', + 'var_dump', 'print_r', 'var_export', + 'date', 'time', 'strtotime', 'mktime', 'microtime', + 'file_exists', 'file_get_contents', 'file_put_contents', 'is_file', 'is_dir', + 'preg_match', 'preg_match_all', 'preg_replace', 'preg_split', + 'header', 'session_start', 'session_destroy', 'ob_start', 'ob_end_clean', 'ob_get_clean', + 'dd', 'dump', + // Swift/iOS built-ins and standard library + 'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure', + 'assert', 'assertionFailure', 'NSLog', + 'abs', 'min', 'max', 'zip', 'stride', 'sequence', 'repeatElement', + 'swap', 'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes', + 'autoreleasepool', 'unsafeBitCast', 'unsafeDowncast', 'numericCast', + 'type', 'MemoryLayout', + // Swift collection/string methods (common noise) + 'map', 'flatMap', 'compactMap', 'filter', 'reduce', 'forEach', 'contains', + 'first', 'last', 'prefix', 'suffix', 'dropFirst', 'dropLast', + 'sorted', 'reversed', 'enumerated', 'joined', 'split', + 'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast', + 'isEmpty', 'count', 'index', 'startIndex', 'endIndex', + // UIKit/Foundation common methods (noise in call graph) + 'addSubview', 'removeFromSuperview', 'layoutSubviews', 'setNeedsLayout', + 'layoutIfNeeded', 'setNeedsDisplay', 'invalidateIntrinsicContentSize', + 'addTarget', 'removeTarget', 'addGestureRecognizer', + 'addConstraint', 'addConstraints', 'removeConstraint', 'removeConstraints', + 'NSLocalizedString', 'Bundle', + 'reloadData', 'reloadSections', 'reloadRows', 'performBatchUpdates', + 'register', 'dequeueReusableCell', 'dequeueReusableSupplementaryView', + 'beginUpdates', 'endUpdates', 'insertRows', 'deleteRows', 'insertSections', 'deleteSections', + 'present', 'dismiss', 'pushViewController', 'popViewController', 'popToRootViewController', + 'performSegue', 'prepare', + // GCD / async + 'DispatchQueue', 'async', 'sync', 'asyncAfter', + 'Task', 'withCheckedContinuation', 'withCheckedThrowingContinuation', + // Combine + 'sink', 'store', 'assign', 'receive', 'subscribe', + // Notification / KVO + 'addObserver', 'removeObserver', 'post', 'NotificationCenter', + // Rust standard library (common noise in call graphs) + 'unwrap', 'expect', 'unwrap_or', 'unwrap_or_else', 'unwrap_or_default', + 'ok', 'err', 'is_ok', 'is_err', 'map', 'map_err', 'and_then', 'or_else', + 'clone', 'to_string', 'to_owned', 'into', 'from', 'as_ref', 'as_mut', + 'iter', 'into_iter', 'collect', 'map', 'filter', 'fold', 'for_each', + 'len', 'is_empty', 'push', 'pop', 'insert', 'remove', 'contains', + 'format', 'write', 'writeln', 'panic', 'unreachable', 'todo', 'unimplemented', + 'vec', 'println', 'eprintln', 'dbg', + 'lock', 'read', 'write', 'try_lock', + 'spawn', 'join', 'sleep', + 'Some', 'None', 'Ok', 'Err', + // Ruby built-ins and Kernel methods + 'puts', 'p', 'pp', 'raise', 'fail', + 'require', 'require_relative', 'load', 'autoload', + 'include', 'extend', 'prepend', + 'attr_accessor', 'attr_reader', 'attr_writer', + 'public', 'private', 'protected', 'module_function', + 'lambda', 'proc', 'block_given?', + 'nil?', 'is_a?', 'kind_of?', 'instance_of?', 'respond_to?', + 'freeze', 'frozen?', 'dup', 'tap', 'yield_self', + // Ruby enumerables + 'each', 'select', 'reject', 'detect', 'collect', + 'inject', 'flat_map', 'each_with_object', 'each_with_index', + 'any?', 'all?', 'none?', 'count', 'first', 'last', + 'sort_by', 'min_by', 'max_by', + 'group_by', 'partition', 'compact', 'flatten', 'uniq', +]); + +/** Check if a name is a built-in function or common noise that should be filtered out */ +export const isBuiltInOrNoise = (name: string): boolean => BUILT_IN_NAMES.has(name); + +/** AST node types that represent a class-like container (for HAS_METHOD edge extraction) */ +export const CLASS_CONTAINER_TYPES = new Set([ + 'class_declaration', 'abstract_class_declaration', + 'interface_declaration', 'struct_declaration', 'record_declaration', + 'class_specifier', 'struct_specifier', + 'impl_item', 'trait_item', 'struct_item', 'enum_item', + 'class_definition', + 'trait_declaration', + 'protocol_declaration', + // Ruby + 'class', + 'module', + // Kotlin + 'object_declaration', + 'companion_object', +]); + +export const CONTAINER_TYPE_TO_LABEL: Record<string, string> = { + class_declaration: 'Class', + abstract_class_declaration: 'Class', + interface_declaration: 'Interface', + struct_declaration: 'Struct', + struct_specifier: 'Struct', + class_specifier: 'Class', + class_definition: 'Class', + impl_item: 'Impl', + trait_item: 'Trait', + struct_item: 'Struct', + enum_item: 'Enum', + trait_declaration: 'Trait', + record_declaration: 'Record', + protocol_declaration: 'Interface', + class: 'Class', + module: 'Module', + object_declaration: 'Class', + companion_object: 'Class', +}; + +/** Walk up AST to find enclosing class/struct/interface/impl, return its generateId or null. + * For Go method_declaration nodes, extracts receiver type (e.g. `func (u *User) Save()` → User struct). */ +export const findEnclosingClassId = (node: any, filePath: string): string | null => { + let current = node.parent; + while (current) { + // Go: method_declaration has a receiver parameter with the struct type + if (current.type === 'method_declaration') { + const receiver = current.childForFieldName?.('receiver'); + if (receiver) { + // receiver is a parameter_list: (u *User) or (u User) + const paramDecl = receiver.namedChildren?.find?.((c: any) => c.type === 'parameter_declaration'); + if (paramDecl) { + const typeNode = paramDecl.childForFieldName?.('type'); + if (typeNode) { + // Unwrap pointer_type (*User → User) + const inner = typeNode.type === 'pointer_type' ? typeNode.firstNamedChild : typeNode; + if (inner && (inner.type === 'type_identifier' || inner.type === 'identifier')) { + return generateId('Struct', `${filePath}:${inner.text}`); + } + } + } + } + } + // Go: type_declaration wrapping a struct_type (type User struct { ... }) + // field_declaration → field_declaration_list → struct_type → type_spec → type_declaration + if (current.type === 'type_declaration') { + const typeSpec = current.children?.find((c: any) => c.type === 'type_spec'); + if (typeSpec) { + const typeBody = typeSpec.childForFieldName?.('type'); + if (typeBody?.type === 'struct_type' || typeBody?.type === 'interface_type') { + const nameNode = typeSpec.childForFieldName?.('name'); + if (nameNode) { + const label = typeBody.type === 'struct_type' ? 'Struct' : 'Interface'; + return generateId(label, `${filePath}:${nameNode.text}`); + } + } + } + } + if (CLASS_CONTAINER_TYPES.has(current.type)) { + // Rust impl_item: for `impl Trait for Struct {}`, pick the type after `for` + if (current.type === 'impl_item') { + const children = current.children ?? []; + const forIdx = children.findIndex((c: any) => c.text === 'for'); + if (forIdx !== -1) { + const nameNode = children.slice(forIdx + 1).find((c: any) => + c.type === 'type_identifier' || c.type === 'identifier' + ); + if (nameNode) { + return generateId('Impl', `${filePath}:${nameNode.text}`); + } + } + // Fall through: plain `impl Struct {}` — use first type_identifier below + } + const nameNode = current.childForFieldName?.('name') + ?? current.children?.find((c: any) => + c.type === 'type_identifier' || c.type === 'identifier' || c.type === 'name' || c.type === 'constant' + ); + if (nameNode) { + const label = CONTAINER_TYPE_TO_LABEL[current.type] || 'Class'; + return generateId(label, `${filePath}:${nameNode.text}`); + } + } + current = current.parent; + } + return null; +}; + +/** + * Extract function name and label from a function_definition or similar AST node. + * Handles C/C++ qualified_identifier (ClassName::MethodName) and other language patterns. + */ +export const extractFunctionName = (node: SyntaxNode): { funcName: string | null; label: string } => { + let funcName: string | null = null; + let label = 'Function'; + + // Swift init/deinit + if (node.type === 'init_declaration' || node.type === 'deinit_declaration') { + return { + funcName: node.type === 'init_declaration' ? 'init' : 'deinit', + label: 'Constructor', + }; + } + + if (FUNCTION_DECLARATION_TYPES.has(node.type)) { + // C/C++: function_definition -> [pointer_declarator ->] function_declarator -> qualified_identifier/identifier + // Unwrap pointer_declarator / reference_declarator wrappers to reach function_declarator + let declarator = node.childForFieldName?.('declarator'); + if (!declarator) { + for (let i = 0; i < node.childCount; i++) { + const c = node.child(i); + if (c?.type === 'function_declarator') { declarator = c; break; } + } + } + while (declarator && (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator')) { + let nextDeclarator = declarator.childForFieldName?.('declarator'); + if (!nextDeclarator) { + for (let i = 0; i < declarator.childCount; i++) { + const c = declarator.child(i); + if (c?.type === 'function_declarator' || c?.type === 'pointer_declarator' || c?.type === 'reference_declarator') { nextDeclarator = c; break; } + } + } + declarator = nextDeclarator; + } + if (declarator) { + let innerDeclarator = declarator.childForFieldName?.('declarator'); + if (!innerDeclarator) { + for (let i = 0; i < declarator.childCount; i++) { + const c = declarator.child(i); + if (c?.type === 'qualified_identifier' || c?.type === 'identifier' || c?.type === 'parenthesized_declarator') { innerDeclarator = c; break; } + } + } + + if (innerDeclarator?.type === 'qualified_identifier') { + let nameNode = innerDeclarator.childForFieldName?.('name'); + if (!nameNode) { + for (let i = 0; i < innerDeclarator.childCount; i++) { + const c = innerDeclarator.child(i); + if (c?.type === 'identifier') { nameNode = c; break; } + } + } + if (nameNode?.text) { + funcName = nameNode.text; + label = 'Method'; + } + } else if (innerDeclarator?.type === 'identifier') { + funcName = innerDeclarator.text; + } else if (innerDeclarator?.type === 'parenthesized_declarator') { + let nestedId: SyntaxNode | null = null; + for (let i = 0; i < innerDeclarator.childCount; i++) { + const c = innerDeclarator.child(i); + if (c?.type === 'qualified_identifier' || c?.type === 'identifier') { nestedId = c; break; } + } + if (nestedId?.type === 'qualified_identifier') { + let nameNode = nestedId.childForFieldName?.('name'); + if (!nameNode) { + for (let i = 0; i < nestedId.childCount; i++) { + const c = nestedId.child(i); + if (c?.type === 'identifier') { nameNode = c; break; } + } + } + if (nameNode?.text) { + funcName = nameNode.text; + label = 'Method'; + } + } else if (nestedId?.type === 'identifier') { + funcName = nestedId.text; + } + } + } + + // Fallback for other languages (Kotlin uses simple_identifier, Swift uses simple_identifier) + if (!funcName) { + let nameNode = node.childForFieldName?.('name'); + if (!nameNode) { + for (let i = 0; i < node.childCount; i++) { + const c = node.child(i); + if (c?.type === 'identifier' || c?.type === 'property_identifier' || c?.type === 'simple_identifier') { nameNode = c; break; } + } + } + funcName = nameNode?.text; + } + } else if (node.type === 'impl_item') { + let funcItem: SyntaxNode | null = null; + for (let i = 0; i < node.childCount; i++) { + const c = node.child(i); + if (c?.type === 'function_item') { funcItem = c; break; } + } + if (funcItem) { + let nameNode = funcItem.childForFieldName?.('name'); + if (!nameNode) { + for (let i = 0; i < funcItem.childCount; i++) { + const c = funcItem.child(i); + if (c?.type === 'identifier') { nameNode = c; break; } + } + } + funcName = nameNode?.text; + label = 'Method'; + } + } else if (node.type === 'method_definition') { + let nameNode = node.childForFieldName?.('name'); + if (!nameNode) { + for (let i = 0; i < node.childCount; i++) { + const c = node.child(i); + if (c?.type === 'property_identifier') { nameNode = c; break; } + } + } + funcName = nameNode?.text; + label = 'Method'; + } else if (node.type === 'method_declaration' || node.type === 'constructor_declaration') { + let nameNode = node.childForFieldName?.('name'); + if (!nameNode) { + for (let i = 0; i < node.childCount; i++) { + const c = node.child(i); + if (c?.type === 'identifier') { nameNode = c; break; } + } + } + funcName = nameNode?.text; + label = 'Method'; + } else if (node.type === 'arrow_function' || node.type === 'function_expression') { + const parent = node.parent; + if (parent?.type === 'variable_declarator') { + let nameNode = parent.childForFieldName?.('name'); + if (!nameNode) { + for (let i = 0; i < parent.childCount; i++) { + const c = parent.child(i); + if (c?.type === 'identifier') { nameNode = c; break; } + } + } + funcName = nameNode?.text; + } + } else if (node.type === 'method' || node.type === 'singleton_method') { + let nameNode = node.childForFieldName?.('name'); + if (!nameNode) { + for (let i = 0; i < node.childCount; i++) { + const c = node.child(i); + if (c?.type === 'identifier') { nameNode = c; break; } + } + } + funcName = nameNode?.text; + label = 'Method'; + } + + return { funcName, label }; +}; /** * Yield control to the event loop so spinners/progress can render. @@ -6,6 +528,26 @@ import { SupportedLanguages } from '../../config/supported-languages.js'; */ export const yieldToEventLoop = (): Promise<void> => new Promise(resolve => setImmediate(resolve)); +/** Ruby extensionless filenames recognised as Ruby source */ +const RUBY_EXTENSIONLESS_FILES = new Set(['Rakefile', 'Gemfile', 'Guardfile', 'Vagrantfile', 'Brewfile']); + +/** + * Find a child of `childType` within a sibling node of `siblingType`. + * Used for Kotlin AST traversal where visibility_modifier lives inside a modifiers sibling. + */ +export const findSiblingChild = (parent: any, siblingType: string, childType: string): any | null => { + for (let i = 0; i < parent.childCount; i++) { + const sibling = parent.child(i); + if (sibling?.type === siblingType) { + for (let j = 0; j < sibling.childCount; j++) { + const child = sibling.child(j); + if (child?.type === childType) return child; + } + } + } + return null; +}; + /** * Map file extension to SupportedLanguage enum */ @@ -20,17 +562,754 @@ export const getLanguageFromFilename = (filename: string): SupportedLanguages | if (filename.endsWith('.py')) return SupportedLanguages.Python; // Java if (filename.endsWith('.java')) return SupportedLanguages.Java; - // C (source and headers) - if (filename.endsWith('.c') || filename.endsWith('.h')) return SupportedLanguages.C; - // C++ (all common extensions) + // C source files + if (filename.endsWith('.c')) return SupportedLanguages.C; + // C++ (all common extensions, including .h) + // .h is parsed as C++ because tree-sitter-cpp is a strict superset of C, so pure-C + // headers parse correctly, and C++ headers (classes, templates) are handled properly. if (filename.endsWith('.cpp') || filename.endsWith('.cc') || filename.endsWith('.cxx') || - filename.endsWith('.hpp') || filename.endsWith('.hxx') || filename.endsWith('.hh')) return SupportedLanguages.CPlusPlus; + filename.endsWith('.h') || filename.endsWith('.hpp') || filename.endsWith('.hxx') || filename.endsWith('.hh')) return SupportedLanguages.CPlusPlus; // C# if (filename.endsWith('.cs')) return SupportedLanguages.CSharp; // Go if (filename.endsWith('.go')) return SupportedLanguages.Go; // Rust if (filename.endsWith('.rs')) return SupportedLanguages.Rust; + // Kotlin + if (filename.endsWith('.kt') || filename.endsWith('.kts')) return SupportedLanguages.Kotlin; + // PHP (all common extensions) + if (filename.endsWith('.php') || filename.endsWith('.phtml') || + filename.endsWith('.php3') || filename.endsWith('.php4') || + filename.endsWith('.php5') || filename.endsWith('.php8')) { + return SupportedLanguages.PHP; + } + // Ruby (extensions) + if (filename.endsWith('.rb') || filename.endsWith('.rake') || filename.endsWith('.gemspec')) { + return SupportedLanguages.Ruby; + } + // Ruby (extensionless files) + const basename = filename.split('/').pop() || filename; + if (RUBY_EXTENSIONLESS_FILES.has(basename)) { + return SupportedLanguages.Ruby; + } + // Swift (extensions) + if (filename.endsWith('.swift')) return SupportedLanguages.Swift; return null; }; +export interface MethodSignature { + parameterCount: number | undefined; + returnType: string | undefined; +} + +const CALL_ARGUMENT_LIST_TYPES = new Set([ + 'arguments', + 'argument_list', + 'value_arguments', +]); + +/** + * Extract parameter count and return type text from an AST method/function node. + * Works across languages by looking for common AST patterns. + */ +export const extractMethodSignature = (node: SyntaxNode | null | undefined): MethodSignature => { + let parameterCount: number | undefined = 0; + let returnType: string | undefined; + let isVariadic = false; + + if (!node) return { parameterCount, returnType }; + + const paramListTypes = new Set([ + 'formal_parameters', 'parameters', 'parameter_list', + 'function_parameters', 'method_parameters', 'function_value_parameters', + ]); + + // Node types that indicate variadic/rest parameters + const VARIADIC_PARAM_TYPES = new Set([ + 'variadic_parameter_declaration', // Go: ...string + 'variadic_parameter', // Rust: extern "C" fn(...) + 'spread_parameter', // Java: Object... args + 'list_splat_pattern', // Python: *args + 'dictionary_splat_pattern', // Python: **kwargs + ]); + + const findParameterList = (current: SyntaxNode): SyntaxNode | null => { + for (const child of current.children) { + if (paramListTypes.has(child.type)) return child; + } + for (const child of current.children) { + const nested = findParameterList(child); + if (nested) return nested; + } + return null; + }; + + const parameterList = ( + paramListTypes.has(node.type) ? node // node itself IS the parameter list (e.g. C# primary constructors) + : node.childForFieldName?.('parameters') + ?? findParameterList(node) + ); + + if (parameterList && paramListTypes.has(parameterList.type)) { + for (const param of parameterList.namedChildren) { + if (param.type === 'comment') continue; + if (param.text === 'self' || param.text === '&self' || param.text === '&mut self' || + param.type === 'self_parameter') { + continue; + } + // Check for variadic parameter types + if (VARIADIC_PARAM_TYPES.has(param.type)) { + isVariadic = true; + continue; + } + // TypeScript/JavaScript: rest parameter — required_parameter containing rest_pattern + if (param.type === 'required_parameter' || param.type === 'optional_parameter') { + for (const child of param.children) { + if (child.type === 'rest_pattern') { + isVariadic = true; + break; + } + } + if (isVariadic) continue; + } + // Kotlin: vararg modifier on a regular parameter + if (param.type === 'parameter' || param.type === 'formal_parameter') { + const prev = param.previousSibling; + if (prev?.type === 'parameter_modifiers' && prev.text.includes('vararg')) { + isVariadic = true; + } + } + parameterCount++; + } + // C/C++: bare `...` token in parameter list (not a named child — check all children) + if (!isVariadic) { + for (const child of parameterList.children) { + if (!child.isNamed && child.text === '...') { + isVariadic = true; + break; + } + } + } + } + + // Return type extraction — language-specific field names + // Go: 'result' field is either a type_identifier or parameter_list (multi-return) + const goResult = node.childForFieldName?.('result'); + if (goResult) { + if (goResult.type === 'parameter_list') { + // Multi-return: extract first parameter's type only (e.g. (*User, error) → *User) + const firstParam = goResult.firstNamedChild; + if (firstParam?.type === 'parameter_declaration') { + const typeNode = firstParam.childForFieldName('type'); + if (typeNode) returnType = typeNode.text; + } else if (firstParam) { + // Unnamed return types: (string, error) — first child is a bare type node + returnType = firstParam.text; + } + } else { + returnType = goResult.text; + } + } + + // Rust: 'return_type' field — the value IS the type node (e.g. primitive_type, type_identifier). + // Skip if the node is a type_annotation (TS/Python), which is handled by the generic loop below. + if (!returnType) { + const rustReturn = node.childForFieldName?.('return_type'); + if (rustReturn && rustReturn.type !== 'type_annotation') { + returnType = rustReturn.text; + } + } + + // C/C++: 'type' field on function_definition + if (!returnType) { + const cppType = node.childForFieldName?.('type'); + if (cppType && cppType.text !== 'void') { + returnType = cppType.text; + } + } + + // C#: 'returns' field on method_declaration + if (!returnType) { + const csReturn = node.childForFieldName?.('returns'); + if (csReturn && csReturn.text !== 'void') { + returnType = csReturn.text; + } + } + + // TS/Rust/Python/C#/Kotlin: type_annotation or return_type child + if (!returnType) { + for (const child of node.children) { + if (child.type === 'type_annotation' || child.type === 'return_type') { + const typeNode = child.children.find((c) => c.isNamed); + if (typeNode) returnType = typeNode.text; + } + } + } + + // Kotlin: fun getUser(): User — return type is a bare user_type child of + // function_declaration. The Kotlin grammar does NOT wrap it in type_annotation + // or return_type; it appears as a direct child after function_value_parameters. + // Note: Kotlin uses function_value_parameters (not a field), so we find it by type. + if (!returnType) { + let paramsEnd = -1; + for (let i = 0; i < node.childCount; i++) { + const child = node.child(i); + if (!child) continue; + if (child.type === 'function_value_parameters' || child.type === 'value_parameters') { + paramsEnd = child.endIndex; + } + if (paramsEnd >= 0 && child.type === 'user_type' && child.startIndex > paramsEnd) { + returnType = child.text; + break; + } + } + } + + if (isVariadic) parameterCount = undefined; + + return { parameterCount, returnType }; +}; + +/** + * Count direct arguments for a call expression across common tree-sitter grammars. + * Returns undefined when the argument container cannot be located cheaply. + */ +export const countCallArguments = (callNode: SyntaxNode | null | undefined): number | undefined => { + if (!callNode) return undefined; + + // Direct field or direct child (most languages) + let argsNode: SyntaxNode | null | undefined = callNode.childForFieldName('arguments') + ?? callNode.children.find((child) => CALL_ARGUMENT_LIST_TYPES.has(child.type)); + + // Kotlin/Swift: call_expression → call_suffix → value_arguments + // Search one level deeper for languages that wrap arguments in a suffix node + if (!argsNode) { + for (const child of callNode.children) { + if (!child.isNamed) continue; + const nested = child.children.find((gc) => CALL_ARGUMENT_LIST_TYPES.has(gc.type)); + if (nested) { argsNode = nested; break; } + } + } + + if (!argsNode) return undefined; + + let count = 0; + for (const child of argsNode.children) { + if (!child.isNamed) continue; + if (child.type === 'comment') continue; + count++; + } + + return count; +}; + +// ── Call-form discrimination (Phase 1, Step D) ───────────────────────── + +/** + * AST node types that indicate a member-access wrapper around the callee name. + * When nameNode.parent.type is one of these, the call is a member call. + */ +const MEMBER_ACCESS_NODE_TYPES = new Set([ + 'member_expression', // TS/JS: obj.method() + 'attribute', // Python: obj.method() + 'member_access_expression', // C#: obj.Method() + 'field_expression', // Rust/C++: obj.method() / ptr->method() + 'selector_expression', // Go: obj.Method() + 'navigation_suffix', // Kotlin/Swift: obj.method() — nameNode sits inside navigation_suffix + 'member_binding_expression', // C#: user?.Method() — null-conditional access +]); + +/** + * Call node types that are inherently constructor invocations. + * Only includes patterns that the tree-sitter queries already capture as @call. + */ +const CONSTRUCTOR_CALL_NODE_TYPES = new Set([ + 'constructor_invocation', // Kotlin: Foo() + 'new_expression', // TS/JS/C++: new Foo() + 'object_creation_expression', // Java/C#/PHP: new Foo() + 'implicit_object_creation_expression', // C# 9: User u = new(...) + 'composite_literal', // Go: User{...} + 'struct_expression', // Rust: User { ... } +]); + +/** + * AST node types for scoped/qualified calls (e.g., Foo::new() in Rust, Foo::bar() in C++). + */ +const SCOPED_CALL_NODE_TYPES = new Set([ + 'scoped_identifier', // Rust: Foo::new() + 'qualified_identifier', // C++: ns::func() +]); + +type CallForm = 'free' | 'member' | 'constructor'; + +/** + * Infer whether a captured call site is a free call, member call, or constructor. + * Returns undefined if the form cannot be determined. + * + * Works by inspecting the AST structure between callNode (@call) and nameNode (@call.name). + * No tree-sitter query changes needed — the distinction is in the node types. + */ +export const inferCallForm = ( + callNode: SyntaxNode, + nameNode: SyntaxNode, +): CallForm | undefined => { + // 1. Constructor: callNode itself is a constructor invocation (Kotlin) + if (CONSTRUCTOR_CALL_NODE_TYPES.has(callNode.type)) { + return 'constructor'; + } + + // 2. Member call: nameNode's parent is a member-access wrapper + const nameParent = nameNode.parent; + if (nameParent && MEMBER_ACCESS_NODE_TYPES.has(nameParent.type)) { + return 'member'; + } + + // 3. PHP: the callNode itself distinguishes member vs free calls + if (callNode.type === 'member_call_expression' || callNode.type === 'nullsafe_member_call_expression') { + return 'member'; + } + if (callNode.type === 'scoped_call_expression') { + return 'member'; // static call Foo::bar() + } + + // 4. Java method_invocation: member if it has an 'object' field + if (callNode.type === 'method_invocation' && callNode.childForFieldName('object')) { + return 'member'; + } + + // 4b. Ruby call with receiver: obj.method + if (callNode.type === 'call' && callNode.childForFieldName('receiver')) { + return 'member'; + } + + // 5. Scoped calls (Rust Foo::new(), C++ ns::func()): treat as free + // The receiver is a type, not an instance — handled differently in Phase 3 + if (nameParent && SCOPED_CALL_NODE_TYPES.has(nameParent.type)) { + return 'free'; + } + + // 6. Default: if nameNode is a direct child of callNode, it's a free call + if (nameNode.parent === callNode || nameParent?.parent === callNode) { + return 'free'; + } + + return undefined; +}; + +/** + * Extract the receiver identifier for member calls. + * Only captures simple identifiers — returns undefined for complex expressions + * like getUser().save() or arr[0].method(). + */ +const SIMPLE_RECEIVER_TYPES = new Set([ + 'identifier', + 'simple_identifier', + 'variable_name', // PHP $variable (tree-sitter-php) + 'name', // PHP name node + 'this', // TS/JS/Java/C# this.method() + 'self', // Rust/Python self.method() + 'super', // TS/JS/Java/Kotlin/Ruby super.method() + 'super_expression', // Kotlin wraps super in super_expression + 'base', // C# base.Method() + 'parent', // PHP parent::method() + 'constant', // Ruby CONSTANT.method() (uppercase identifiers) +]); + +export const extractReceiverName = ( + nameNode: SyntaxNode, +): string | undefined => { + const parent = nameNode.parent; + if (!parent) return undefined; + + // PHP: member_call_expression / nullsafe_member_call_expression — receiver is on the callNode + // Java: method_invocation — receiver is the 'object' field on callNode + // For these, parent of nameNode is the call itself, so check the call's object field + const callNode = parent.parent ?? parent; + + let receiver: SyntaxNode | null = null; + + // Try standard field names used across grammars + receiver = parent.childForFieldName('object') // TS/JS member_expression, Python attribute, PHP, Java + ?? parent.childForFieldName('value') // Rust field_expression + ?? parent.childForFieldName('operand') // Go selector_expression + ?? parent.childForFieldName('expression') // C# member_access_expression + ?? parent.childForFieldName('argument'); // C++ field_expression + + // Java method_invocation: 'object' field is on the callNode, not on nameNode's parent + if (!receiver && callNode.type === 'method_invocation') { + receiver = callNode.childForFieldName('object'); + } + + // PHP: member_call_expression has 'object' on the call node + if (!receiver && (callNode.type === 'member_call_expression' || callNode.type === 'nullsafe_member_call_expression')) { + receiver = callNode.childForFieldName('object'); + } + + // Ruby: call node has 'receiver' field + if (!receiver && parent.type === 'call') { + receiver = parent.childForFieldName('receiver'); + } + + // PHP scoped_call_expression (parent::method(), self::method()): + // nameNode's direct parent IS the scoped_call_expression (name is a direct child) + if (!receiver && (parent.type === 'scoped_call_expression' || callNode.type === 'scoped_call_expression')) { + const scopedCall = parent.type === 'scoped_call_expression' ? parent : callNode; + receiver = scopedCall.childForFieldName('scope'); + // relative_scope wraps 'parent'/'self'/'static' — unwrap to get the keyword + if (receiver?.type === 'relative_scope') { + receiver = receiver.firstChild; + } + } + + // C# null-conditional: user?.Save() → conditional_access_expression wraps member_binding_expression + if (!receiver && parent.type === 'member_binding_expression') { + const condAccess = parent.parent; + if (condAccess?.type === 'conditional_access_expression') { + receiver = condAccess.firstNamedChild; + } + } + + // Kotlin/Swift: navigation_expression target is the first child + if (!receiver && parent.type === 'navigation_suffix') { + const navExpr = parent.parent; + if (navExpr?.type === 'navigation_expression') { + // First named child is the target (receiver) + for (const child of navExpr.children) { + if (child.isNamed && child !== parent) { + receiver = child; + break; + } + } + } + } + + if (!receiver) return undefined; + + // Only capture simple identifiers — refuse complex expressions + if (SIMPLE_RECEIVER_TYPES.has(receiver.type)) { + return receiver.text; + } + + // Python super().method(): receiver is a call node `super()` — extract the function name + if (receiver.type === 'call') { + const func = receiver.childForFieldName('function'); + if (func?.text === 'super') return 'super'; + } + + return undefined; +}; + +/** + * Extract the raw receiver AST node for a member call. + * Unlike extractReceiverName, this returns the receiver node regardless of its type — + * including call_expression / method_invocation nodes that appear in chained calls + * like `svc.getUser().save()`. + * + * Returns undefined when the call is not a member call or when no receiver node + * can be found (e.g. top-level free calls). + */ +export const extractReceiverNode = ( + nameNode: SyntaxNode, +): SyntaxNode | undefined => { + const parent = nameNode.parent; + if (!parent) return undefined; + + const callNode = parent.parent ?? parent; + + let receiver: SyntaxNode | null = null; + + receiver = parent.childForFieldName('object') + ?? parent.childForFieldName('value') + ?? parent.childForFieldName('operand') + ?? parent.childForFieldName('expression') + ?? parent.childForFieldName('argument'); + + if (!receiver && callNode.type === 'method_invocation') { + receiver = callNode.childForFieldName('object'); + } + + if (!receiver && (callNode.type === 'member_call_expression' || callNode.type === 'nullsafe_member_call_expression')) { + receiver = callNode.childForFieldName('object'); + } + + if (!receiver && parent.type === 'call') { + receiver = parent.childForFieldName('receiver'); + } + + if (!receiver && (parent.type === 'scoped_call_expression' || callNode.type === 'scoped_call_expression')) { + const scopedCall = parent.type === 'scoped_call_expression' ? parent : callNode; + receiver = scopedCall.childForFieldName('scope'); + if (receiver?.type === 'relative_scope') { + receiver = receiver.firstChild; + } + } + + if (!receiver && parent.type === 'member_binding_expression') { + const condAccess = parent.parent; + if (condAccess?.type === 'conditional_access_expression') { + receiver = condAccess.firstNamedChild; + } + } + + if (!receiver && parent.type === 'navigation_suffix') { + const navExpr = parent.parent; + if (navExpr?.type === 'navigation_expression') { + for (const child of navExpr.children) { + if (child.isNamed && child !== parent) { + receiver = child; + break; + } + } + } + } + + return receiver ?? undefined; +}; + +export const isVerboseIngestionEnabled = (): boolean => { + const raw = process.env.GITNEXUS_VERBOSE; + if (!raw) return false; + const value = raw.toLowerCase(); + return value === '1' || value === 'true' || value === 'yes'; +}; + +// ── Chained-call extraction ─────────────────────────────────────────────── + +/** Node types representing call expressions across supported languages. */ +export const CALL_EXPRESSION_TYPES = new Set([ + 'call_expression', // TS/JS/C/C++/Go/Rust + 'method_invocation', // Java + 'member_call_expression', // PHP + 'nullsafe_member_call_expression', // PHP ?. + 'call', // Python/Ruby + 'invocation_expression', // C# +]); + +/** + * Hard limit on chain depth to prevent runaway recursion. + * For `a.b().c().d()`, the chain has depth 2 (b and c before d). + */ +export const MAX_CHAIN_DEPTH = 3; + +/** + * Walk a receiver AST node that is itself a call expression, accumulating the + * chain of intermediate method names up to MAX_CHAIN_DEPTH. + * + * For `svc.getUser().save()`, called with the receiver of `save` (getUser() call): + * returns { chain: ['getUser'], baseReceiverName: 'svc' } + * + * For `a.b().c().d()`, called with the receiver of `d` (c() call): + * returns { chain: ['b', 'c'], baseReceiverName: 'a' } + */ +export function extractCallChain( + receiverCallNode: SyntaxNode, +): { chain: string[]; baseReceiverName: string | undefined } | undefined { + const chain: string[] = []; + let current: SyntaxNode = receiverCallNode; + + while (CALL_EXPRESSION_TYPES.has(current.type) && chain.length < MAX_CHAIN_DEPTH) { + // Extract the method name from this call node. + const funcNode = current.childForFieldName?.('function') + ?? current.childForFieldName?.('name') + ?? current.childForFieldName?.('method'); // Ruby `call` node + let methodName: string | undefined; + let innerReceiver: SyntaxNode | null = null; + if (funcNode) { + // member_expression / attribute: last named child is the method identifier + methodName = funcNode.lastNamedChild?.text ?? funcNode.text; + } + // Kotlin/Swift: call_expression exposes callee as firstNamedChild, not a field. + // navigation_expression: method name is in navigation_suffix → simple_identifier. + if (!funcNode && current.type === 'call_expression') { + const callee = current.firstNamedChild; + if (callee?.type === 'navigation_expression') { + const suffix = callee.lastNamedChild; + if (suffix?.type === 'navigation_suffix') { + methodName = suffix.lastNamedChild?.text; + // The receiver is the part of navigation_expression before the suffix + for (let i = 0; i < callee.namedChildCount; i++) { + const child = callee.namedChild(i); + if (child && child.type !== 'navigation_suffix') { + innerReceiver = child; + break; + } + } + } + } + } + if (!methodName) break; + chain.unshift(methodName); // build chain outermost-last + + // Walk into the receiver of this call to continue the chain + if (!innerReceiver && funcNode) { + innerReceiver = funcNode.childForFieldName?.('object') + ?? funcNode.childForFieldName?.('value') + ?? funcNode.childForFieldName?.('operand') + ?? funcNode.childForFieldName?.('expression'); + } + // Java method_invocation: object field is on the call node + if (!innerReceiver && current.type === 'method_invocation') { + innerReceiver = current.childForFieldName?.('object'); + } + // PHP member_call_expression + if (!innerReceiver && (current.type === 'member_call_expression' || current.type === 'nullsafe_member_call_expression')) { + innerReceiver = current.childForFieldName?.('object'); + } + // Ruby `call` node: receiver field is on the call node itself + if (!innerReceiver && current.type === 'call') { + innerReceiver = current.childForFieldName?.('receiver'); + } + + if (!innerReceiver) break; + + if (CALL_EXPRESSION_TYPES.has(innerReceiver.type)) { + current = innerReceiver; // continue walking + } else { + // Reached a simple identifier — the base receiver + return { chain, baseReceiverName: innerReceiver.text || undefined }; + } + } + + return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined; +} + +/** Node types representing member/field access across languages. */ +const FIELD_ACCESS_NODE_TYPES = new Set([ + 'member_expression', // TS/JS + 'member_access_expression', // C# + 'selector_expression', // Go + 'field_expression', // Rust/C++ + 'field_access', // Java + 'attribute', // Python + 'navigation_expression', // Kotlin/Swift + 'member_binding_expression', // C# null-conditional (user?.Address) +]); + +/** One step in a mixed receiver chain. */ +export type MixedChainStep = { kind: 'field' | 'call'; name: string }; + +/** + * Walk a receiver AST node that may interleave field accesses and method calls, + * building a unified chain of steps up to MAX_CHAIN_DEPTH. + * + * For `svc.getUser().address.save()`, called with the receiver of `save` + * (`svc.getUser().address`, a field access node): + * returns { chain: [{ kind:'call', name:'getUser' }, { kind:'field', name:'address' }], + * baseReceiverName: 'svc' } + * + * For `user.getAddress().city.getName()`, called with receiver of `getName` + * (`user.getAddress().city`): + * returns { chain: [{ kind:'call', name:'getAddress' }, { kind:'field', name:'city' }], + * baseReceiverName: 'user' } + * + * Pure field chains and pure call chains are special cases (all steps same kind). + */ +export function extractMixedChain( + receiverNode: SyntaxNode, +): { chain: MixedChainStep[]; baseReceiverName: string | undefined } | undefined { + const chain: MixedChainStep[] = []; + let current: SyntaxNode = receiverNode; + + while (chain.length < MAX_CHAIN_DEPTH) { + if (CALL_EXPRESSION_TYPES.has(current.type)) { + // ── Call expression: extract method name + inner receiver ──────────── + const funcNode = current.childForFieldName?.('function') + ?? current.childForFieldName?.('name') + ?? current.childForFieldName?.('method'); + let methodName: string | undefined; + let innerReceiver: SyntaxNode | null = null; + + if (funcNode) { + methodName = funcNode.lastNamedChild?.text ?? funcNode.text; + } + // Kotlin/Swift: call_expression → navigation_expression + if (!funcNode && current.type === 'call_expression') { + const callee = current.firstNamedChild; + if (callee?.type === 'navigation_expression') { + const suffix = callee.lastNamedChild; + if (suffix?.type === 'navigation_suffix') { + methodName = suffix.lastNamedChild?.text; + for (let i = 0; i < callee.namedChildCount; i++) { + const child = callee.namedChild(i); + if (child && child.type !== 'navigation_suffix') { innerReceiver = child; break; } + } + } + } + } + if (!methodName) break; + chain.unshift({ kind: 'call', name: methodName }); + + if (!innerReceiver && funcNode) { + innerReceiver = funcNode.childForFieldName?.('object') + ?? funcNode.childForFieldName?.('value') + ?? funcNode.childForFieldName?.('operand') + ?? funcNode.childForFieldName?.('argument') // C/C++ field_expression + ?? funcNode.childForFieldName?.('expression') + ?? null; + } + if (!innerReceiver && current.type === 'method_invocation') { + innerReceiver = current.childForFieldName?.('object') ?? null; + } + if (!innerReceiver && (current.type === 'member_call_expression' || current.type === 'nullsafe_member_call_expression')) { + innerReceiver = current.childForFieldName?.('object') ?? null; + } + if (!innerReceiver && current.type === 'call') { + innerReceiver = current.childForFieldName?.('receiver') ?? null; + } + if (!innerReceiver) break; + + if (CALL_EXPRESSION_TYPES.has(innerReceiver.type) || FIELD_ACCESS_NODE_TYPES.has(innerReceiver.type)) { + current = innerReceiver; + } else { + return { chain, baseReceiverName: innerReceiver.text || undefined }; + } + } else if (FIELD_ACCESS_NODE_TYPES.has(current.type)) { + // ── Field/member access: extract property name + inner object ───────── + let propertyName: string | undefined; + let innerObject: SyntaxNode | null = null; + + if (current.type === 'navigation_expression') { + for (const child of current.children ?? []) { + if (child.type === 'navigation_suffix') { + for (const sc of child.children ?? []) { + if (sc.isNamed && sc.type !== '.') { propertyName = sc.text; break; } + } + } else if (child.isNamed && !innerObject) { + innerObject = child; + } + } + } else if (current.type === 'attribute') { + innerObject = current.childForFieldName?.('object') ?? null; + propertyName = current.childForFieldName?.('attribute')?.text; + } else { + innerObject = current.childForFieldName?.('object') + ?? current.childForFieldName?.('value') + ?? current.childForFieldName?.('operand') + ?? current.childForFieldName?.('argument') // C/C++ field_expression + ?? current.childForFieldName?.('expression') + ?? null; + propertyName = (current.childForFieldName?.('property') + ?? current.childForFieldName?.('field') + ?? current.childForFieldName?.('name'))?.text; + } + + if (!propertyName) break; + chain.unshift({ kind: 'field', name: propertyName }); + + if (!innerObject) break; + + if (CALL_EXPRESSION_TYPES.has(innerObject.type) || FIELD_ACCESS_NODE_TYPES.has(innerObject.type)) { + current = innerObject; + } else { + return { chain, baseReceiverName: innerObject.text || undefined }; + } + } else { + // Simple identifier — this is the base receiver + return chain.length > 0 + ? { chain, baseReceiverName: current.text || undefined } + : undefined; + } + } + + return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined; +} diff --git a/gitnexus/src/core/ingestion/workers/parse-worker.ts b/gitnexus/src/core/ingestion/workers/parse-worker.ts index 31e4d02e37..11c3537131 100644 --- a/gitnexus/src/core/ingestion/workers/parse-worker.ts +++ b/gitnexus/src/core/ingestion/workers/parse-worker.ts @@ -9,10 +9,47 @@ import CPP from 'tree-sitter-cpp'; import CSharp from 'tree-sitter-c-sharp'; import Go from 'tree-sitter-go'; import Rust from 'tree-sitter-rust'; +import PHP from 'tree-sitter-php'; +import Ruby from 'tree-sitter-ruby'; +import { createRequire } from 'node:module'; import { SupportedLanguages } from '../../../config/supported-languages.js'; import { LANGUAGE_QUERIES } from '../tree-sitter-queries.js'; -import { getLanguageFromFilename } from '../utils.js'; +import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from '../constants.js'; + +// tree-sitter-swift is an optionalDependency — may not be installed +const _require = createRequire(import.meta.url); +let Swift: any = null; +try { Swift = _require('tree-sitter-swift'); } catch {} + +// tree-sitter-kotlin is an optionalDependency — may not be installed +let Kotlin: any = null; +try { Kotlin = _require('tree-sitter-kotlin'); } catch {} +import { + getLanguageFromFilename, + FUNCTION_NODE_TYPES, + extractFunctionName, + isBuiltInOrNoise, + getDefinitionNodeFromCaptures, + findEnclosingClassId, + extractMethodSignature, + countCallArguments, + inferCallForm, + extractReceiverName, + extractReceiverNode, + extractMixedChain, + type MixedChainStep, +} from '../utils.js'; +import { buildTypeEnv } from '../type-env.js'; +import type { ConstructorBinding } from '../type-env.js'; +import { isNodeExported } from '../export-detection.js'; +import { detectFrameworkFromAST } from '../framework-detection.js'; +import { typeConfigs } from '../type-extractors/index.js'; import { generateId } from '../../../lib/utils.js'; +import { extractNamedBindings } from '../named-binding-extraction.js'; +import { appendKotlinWildcard } from '../resolvers/index.js'; +import { callRouters } from '../call-routing.js'; +import { extractPropertyDeclaredType } from '../type-extractors/shared.js'; +import type { NodeLabel } from '../../graph/types.js'; // ============================================================================ // Types for serializable results @@ -26,8 +63,13 @@ interface ParsedNode { filePath: string; startLine: number; endLine: number; - language: string; + language: SupportedLanguages; isExported: boolean; + astFrameworkMultiplier?: number; + astFrameworkReason?: string; + description?: string; + parameterCount?: number; + returnType?: string; }; } @@ -35,7 +77,7 @@ interface ParsedRelationship { id: string; sourceId: string; targetId: string; - type: 'DEFINES'; + type: 'DEFINES' | 'HAS_METHOD' | 'HAS_PROPERTY'; confidence: number; reason: string; } @@ -44,13 +86,19 @@ interface ParsedSymbol { filePath: string; name: string; nodeId: string; - type: string; + type: NodeLabel; + parameterCount?: number; + returnType?: string; + declaredType?: string; + ownerId?: string; } export interface ExtractedImport { filePath: string; rawImportPath: string; - language: string; + language: SupportedLanguages; + /** Named bindings from the import (e.g., import {User as U} → [{local:'U', exported:'User'}]) */ + namedBindings?: { local: string; exported: string }[]; } export interface ExtractedCall { @@ -58,23 +106,72 @@ export interface ExtractedCall { calledName: string; /** generateId of enclosing function, or generateId('File', filePath) for top-level */ sourceId: string; + argCount?: number; + /** Discriminates free function calls from member/constructor calls */ + callForm?: 'free' | 'member' | 'constructor'; + /** Simple identifier of the receiver for member calls (e.g., 'user' in user.save()) */ + receiverName?: string; + /** Resolved type name of the receiver (e.g., 'User' for user.save() when user: User) */ + receiverTypeName?: string; + /** + * Unified mixed chain when the receiver is a chain of field accesses and/or method calls. + * Steps are ordered base-first (innermost to outermost). Examples: + * `svc.getUser().save()` → chain=[{kind:'call',name:'getUser'}], receiverName='svc' + * `user.address.save()` → chain=[{kind:'field',name:'address'}], receiverName='user' + * `svc.getUser().address.save()` → chain=[{kind:'call',name:'getUser'},{kind:'field',name:'address'}] + * Length is capped at MAX_CHAIN_DEPTH (3). + */ + receiverMixedChain?: MixedChainStep[]; +} + +export interface ExtractedAssignment { + filePath: string; + /** generateId of enclosing function, or generateId('File', filePath) for top-level */ + sourceId: string; + /** Receiver text (e.g., 'user' from user.address = value) */ + receiverText: string; + /** Property name being written (e.g., 'address') */ + propertyName: string; + /** Resolved type name of the receiver if available from TypeEnv */ + receiverTypeName?: string; } export interface ExtractedHeritage { filePath: string; className: string; parentName: string; - /** 'extends' | 'implements' | 'trait-impl' */ + /** 'extends' | 'implements' | 'trait-impl' | 'include' | 'extend' | 'prepend' */ kind: string; } +export interface ExtractedRoute { + filePath: string; + httpMethod: string; + routePath: string | null; + controllerName: string | null; + methodName: string | null; + middleware: string[]; + prefix: string | null; + lineNumber: number; +} + +/** Constructor bindings keyed by filePath for cross-file type resolution */ +export interface FileConstructorBindings { + filePath: string; + bindings: ConstructorBinding[]; +} + export interface ParseWorkerResult { nodes: ParsedNode[]; relationships: ParsedRelationship[]; symbols: ParsedSymbol[]; imports: ExtractedImport[]; calls: ExtractedCall[]; + assignments: ExtractedAssignment[]; heritage: ExtractedHeritage[]; + routes: ExtractedRoute[]; + constructorBindings: FileConstructorBindings[]; + skippedLanguages: Record<string, number>; fileCount: number; } @@ -100,6 +197,23 @@ const languageMap: Record<string, any> = { [SupportedLanguages.CSharp]: CSharp, [SupportedLanguages.Go]: Go, [SupportedLanguages.Rust]: Rust, + ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}), + [SupportedLanguages.PHP]: PHP.php_only, + [SupportedLanguages.Ruby]: Ruby, + ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}), +}; + +/** + * Check if a language grammar is available in this worker. + * Duplicated from parser-loader.ts because workers can't import from the main thread. + * Extra filePath parameter needed to distinguish .tsx from .ts (different grammars + * under the same SupportedLanguages.TypeScript key). + */ +const isLanguageAvailable = (language: SupportedLanguages, filePath: string): boolean => { + const key = language === SupportedLanguages.TypeScript && filePath.endsWith('.tsx') + ? `${language}:tsx` + : language; + return key in languageMap && languageMap[key] != null; }; const setLanguage = (language: SupportedLanguages, filePath: string): void => { @@ -111,137 +225,18 @@ const setLanguage = (language: SupportedLanguages, filePath: string): void => { parser.setLanguage(lang); }; -// ============================================================================ -// Export detection (copied — needs AST parent traversal, can't cross threads) -// ============================================================================ - -const isNodeExported = (node: any, name: string, language: string): boolean => { - let current = node; - - switch (language) { - case 'javascript': - case 'typescript': - while (current) { - const type = current.type; - if (type === 'export_statement' || - type === 'export_specifier' || - type === 'lexical_declaration' && current.parent?.type === 'export_statement') { - return true; - } - if (current.text?.startsWith('export ')) { - return true; - } - current = current.parent; - } - return false; - - case 'python': - return !name.startsWith('_'); - - case 'java': - while (current) { - if (current.parent) { - const parent = current.parent; - for (let i = 0; i < parent.childCount; i++) { - const child = parent.child(i); - if (child?.type === 'modifiers' && child.text?.includes('public')) { - return true; - } - } - if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') { - if (parent.text?.trimStart().startsWith('public')) { - return true; - } - } - } - current = current.parent; - } - return false; - - case 'csharp': - while (current) { - if (current.type === 'modifier' || current.type === 'modifiers') { - if (current.text?.includes('public')) return true; - } - current = current.parent; - } - return false; - - case 'go': - if (name.length === 0) return false; - const first = name[0]; - return first === first.toUpperCase() && first !== first.toLowerCase(); - - case 'rust': - while (current) { - if (current.type === 'visibility_modifier') { - if (current.text?.includes('pub')) return true; - } - current = current.parent; - } - return false; - - case 'c': - case 'cpp': - return false; - - default: - return false; - } -}; +// isNodeExported imported from ../export-detection.js (shared module) // ============================================================================ // Enclosing function detection (for call extraction) // ============================================================================ -const FUNCTION_NODE_TYPES = new Set([ - 'function_declaration', 'arrow_function', 'function_expression', - 'method_definition', 'generator_function_declaration', - 'function_definition', 'async_function_declaration', 'async_arrow_function', - 'method_declaration', 'constructor_declaration', - 'local_function_statement', 'function_item', 'impl_item', -]); - /** Walk up AST to find enclosing function, return its generateId or null for top-level */ const findEnclosingFunctionId = (node: any, filePath: string): string | null => { let current = node.parent; while (current) { if (FUNCTION_NODE_TYPES.has(current.type)) { - let funcName: string | null = null; - let label = 'Function'; - - if (['function_declaration', 'function_definition', 'async_function_declaration', - 'generator_function_declaration', 'function_item'].includes(current.type)) { - const nameNode = current.childForFieldName?.('name') || - current.children?.find((c: any) => c.type === 'identifier' || c.type === 'property_identifier'); - funcName = nameNode?.text; - } else if (current.type === 'impl_item') { - const funcItem = current.children?.find((c: any) => c.type === 'function_item'); - if (funcItem) { - const nameNode = funcItem.childForFieldName?.('name') || - funcItem.children?.find((c: any) => c.type === 'identifier'); - funcName = nameNode?.text; - label = 'Method'; - } - } else if (current.type === 'method_definition') { - const nameNode = current.childForFieldName?.('name') || - current.children?.find((c: any) => c.type === 'property_identifier'); - funcName = nameNode?.text; - label = 'Method'; - } else if (current.type === 'method_declaration' || current.type === 'constructor_declaration') { - const nameNode = current.childForFieldName?.('name') || - current.children?.find((c: any) => c.type === 'identifier'); - funcName = nameNode?.text; - label = 'Method'; - } else if (current.type === 'arrow_function' || current.type === 'function_expression') { - const parent = current.parent; - if (parent?.type === 'variable_declarator') { - const nameNode = parent.childForFieldName?.('name') || - parent.children?.find((c: any) => c.type === 'identifier'); - funcName = nameNode?.text; - } - } - + const { funcName, label } = extractFunctionName(current); if (funcName) { return generateId(label, `${filePath}:${funcName}`); } @@ -251,36 +246,11 @@ const findEnclosingFunctionId = (node: any, filePath: string): string | null => return null; }; -const BUILT_INS = new Set([ - 'console', 'log', 'warn', 'error', 'info', 'debug', - 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', - 'parseInt', 'parseFloat', 'isNaN', 'isFinite', - 'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent', - 'JSON', 'parse', 'stringify', - 'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt', - 'Map', 'Set', 'WeakMap', 'WeakSet', - 'Promise', 'resolve', 'reject', 'then', 'catch', 'finally', - 'Math', 'Date', 'RegExp', 'Error', - 'require', 'import', 'export', 'fetch', 'Response', 'Request', - 'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext', - 'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue', - 'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy', - 'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every', - 'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split', - 'push', 'pop', 'shift', 'unshift', 'sort', 'reverse', - 'keys', 'values', 'entries', 'assign', 'freeze', 'seal', - 'hasOwnProperty', 'toString', 'valueOf', - 'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple', - 'open', 'read', 'write', 'close', 'append', 'extend', 'update', - 'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr', - 'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs', -]); - // ============================================================================ // Label detection from capture map // ============================================================================ -const getLabelFromCaptures = (captureMap: Record<string, any>): string | null => { +const getLabelFromCaptures = (captureMap: Record<string, any>): NodeLabel | null => { // Skip imports (handled separately) and calls if (captureMap['import'] || captureMap['call']) return null; if (!captureMap['name']) return null; @@ -310,6 +280,9 @@ const getLabelFromCaptures = (captureMap: Record<string, any>): string | null => return 'CodeElement'; }; +// DEFINITION_CAPTURE_KEYS and getDefinitionNodeFromCaptures imported from ../utils.js + + // ============================================================================ // Process a batch of files // ============================================================================ @@ -321,7 +294,11 @@ const processBatch = (files: ParseWorkerInput[], onProgress?: (filesProcessed: n symbols: [], imports: [], calls: [], + assignments: [], heritage: [], + routes: [], + constructorBindings: [], + skippedLanguages: {}, fileCount: 0, }; @@ -372,20 +349,511 @@ const processBatch = (files: ParseWorkerInput[], onProgress?: (filesProcessed: n // Process regular files for this language if (regularFiles.length > 0) { - setLanguage(language, regularFiles[0].path); - processFileGroup(regularFiles, language, queryString, result, onFileProcessed); + if (isLanguageAvailable(language, regularFiles[0].path)) { + try { + setLanguage(language, regularFiles[0].path); + processFileGroup(regularFiles, language, queryString, result, onFileProcessed); + } catch { + // parser unavailable — skip this language group + } + } else { + result.skippedLanguages[language] = (result.skippedLanguages[language] || 0) + regularFiles.length; + } } // Process tsx files separately (different grammar) if (tsxFiles.length > 0) { - setLanguage(language, tsxFiles[0].path); - processFileGroup(tsxFiles, language, queryString, result, onFileProcessed); + if (isLanguageAvailable(language, tsxFiles[0].path)) { + try { + setLanguage(language, tsxFiles[0].path); + processFileGroup(tsxFiles, language, queryString, result, onFileProcessed); + } catch { + // parser unavailable — skip this language group + } + } else { + result.skippedLanguages[language] = (result.skippedLanguages[language] || 0) + tsxFiles.length; + } } } return result; }; +// ============================================================================ +// PHP Eloquent metadata extraction +// ============================================================================ + +/** Eloquent model properties whose array values are worth indexing */ +const ELOQUENT_ARRAY_PROPS = new Set(['fillable', 'casts', 'hidden', 'guarded', 'with', 'appends']); + +/** Eloquent relationship method names */ +const ELOQUENT_RELATIONS = new Set([ + 'hasMany', 'hasOne', 'belongsTo', 'belongsToMany', + 'morphTo', 'morphMany', 'morphOne', 'morphToMany', 'morphedByMany', + 'hasManyThrough', 'hasOneThrough', +]); + +function findDescendant(node: any, type: string): any { + if (node.type === type) return node; + for (const child of (node.children ?? [])) { + const found = findDescendant(child, type); + if (found) return found; + } + return null; +} + +function extractStringContent(node: any): string | null { + if (!node) return null; + const content = node.children?.find((c: any) => c.type === 'string_content'); + if (content) return content.text; + if (node.type === 'string_content') return node.text; + return null; +} + +/** + * For a PHP property_declaration node, extract array values as a description string. + * Returns null if not an Eloquent model property or no array values found. + */ +function extractPhpPropertyDescription(propName: string, propDeclNode: any): string | null { + if (!ELOQUENT_ARRAY_PROPS.has(propName)) return null; + + const arrayNode = findDescendant(propDeclNode, 'array_creation_expression'); + if (!arrayNode) return null; + + const items: string[] = []; + for (const child of (arrayNode.children ?? [])) { + if (child.type !== 'array_element_initializer') continue; + const children = child.children ?? []; + const arrowIdx = children.findIndex((c: any) => c.type === '=>'); + if (arrowIdx !== -1) { + // key => value pair (used in $casts) + const key = extractStringContent(children[arrowIdx - 1]); + const val = extractStringContent(children[arrowIdx + 1]); + if (key && val) items.push(`${key}:${val}`); + } else { + // Simple value (used in $fillable, $hidden, etc.) + const val = extractStringContent(children[0]); + if (val) items.push(val); + } + } + + return items.length > 0 ? items.join(', ') : null; +} + +/** + * For a PHP method_declaration node, detect if it defines an Eloquent relationship. + * Returns description like "hasMany(Post)" or null. + */ +function extractEloquentRelationDescription(methodNode: any): string | null { + function findRelationCall(node: any): any { + if (node.type === 'member_call_expression') { + const children = node.children ?? []; + const objectNode = children.find((c: any) => c.type === 'variable_name' && c.text === '$this'); + const nameNode = children.find((c: any) => c.type === 'name'); + if (objectNode && nameNode && ELOQUENT_RELATIONS.has(nameNode.text)) return node; + } + for (const child of (node.children ?? [])) { + const found = findRelationCall(child); + if (found) return found; + } + return null; + } + + const callNode = findRelationCall(methodNode); + if (!callNode) return null; + + const relType = callNode.children?.find((c: any) => c.type === 'name')?.text; + const argsNode = callNode.children?.find((c: any) => c.type === 'arguments'); + let targetModel: string | null = null; + if (argsNode) { + const firstArg = argsNode.children?.find((c: any) => c.type === 'argument'); + if (firstArg) { + const classConstant = firstArg.children?.find((c: any) => + c.type === 'class_constant_access_expression' + ); + if (classConstant) { + targetModel = classConstant.children?.find((c: any) => c.type === 'name')?.text ?? null; + } + } + } + + if (relType && targetModel) return `${relType}(${targetModel})`; + if (relType) return relType; + return null; +} + +// ============================================================================ +// Laravel Route Extraction (procedural AST walk) +// ============================================================================ + +interface RouteGroupContext { + middleware: string[]; + prefix: string | null; + controller: string | null; +} + +const ROUTE_HTTP_METHODS = new Set([ + 'get', 'post', 'put', 'patch', 'delete', 'options', 'any', 'match', +]); + +const ROUTE_RESOURCE_METHODS = new Set(['resource', 'apiResource']); + +const RESOURCE_ACTIONS = ['index', 'create', 'store', 'show', 'edit', 'update', 'destroy']; +const API_RESOURCE_ACTIONS = ['index', 'store', 'show', 'update', 'destroy']; + +/** Check if node is a scoped_call_expression with object 'Route' */ +function isRouteStaticCall(node: any): boolean { + if (node.type !== 'scoped_call_expression') return false; + const obj = node.childForFieldName?.('object') ?? node.children?.[0]; + return obj?.text === 'Route'; +} + +/** Get the method name from a scoped_call_expression or member_call_expression */ +function getCallMethodName(node: any): string | null { + const nameNode = node.childForFieldName?.('name') ?? + node.children?.find((c: any) => c.type === 'name'); + return nameNode?.text ?? null; +} + +/** Get the arguments node from a call expression */ +function getArguments(node: any): any { + return node.children?.find((c: any) => c.type === 'arguments') ?? null; +} + +/** Find the closure body inside arguments */ +function findClosureBody(argsNode: any): any | null { + if (!argsNode) return null; + for (const child of argsNode.children ?? []) { + if (child.type === 'argument') { + for (const inner of child.children ?? []) { + if (inner.type === 'anonymous_function' || + inner.type === 'arrow_function') { + return inner.childForFieldName?.('body') ?? + inner.children?.find((c: any) => c.type === 'compound_statement'); + } + } + } + if (child.type === 'anonymous_function' || + child.type === 'arrow_function') { + return child.childForFieldName?.('body') ?? + child.children?.find((c: any) => c.type === 'compound_statement'); + } + } + return null; +} + +/** Extract first string argument from arguments node */ +function extractFirstStringArg(argsNode: any): string | null { + if (!argsNode) return null; + for (const child of argsNode.children ?? []) { + const target = child.type === 'argument' ? child.children?.[0] : child; + if (!target) continue; + if (target.type === 'string' || target.type === 'encapsed_string') { + return extractStringContent(target); + } + } + return null; +} + +/** Extract middleware from arguments — handles string or array */ +function extractMiddlewareArg(argsNode: any): string[] { + if (!argsNode) return []; + for (const child of argsNode.children ?? []) { + const target = child.type === 'argument' ? child.children?.[0] : child; + if (!target) continue; + if (target.type === 'string' || target.type === 'encapsed_string') { + const val = extractStringContent(target); + return val ? [val] : []; + } + if (target.type === 'array_creation_expression') { + const items: string[] = []; + for (const el of target.children ?? []) { + if (el.type === 'array_element_initializer') { + const str = el.children?.find((c: any) => c.type === 'string' || c.type === 'encapsed_string'); + const val = str ? extractStringContent(str) : null; + if (val) items.push(val); + } + } + return items; + } + } + return []; +} + +/** Extract Controller::class from arguments */ +function extractClassArg(argsNode: any): string | null { + if (!argsNode) return null; + for (const child of argsNode.children ?? []) { + const target = child.type === 'argument' ? child.children?.[0] : child; + if (target?.type === 'class_constant_access_expression') { + return target.children?.find((c: any) => c.type === 'name')?.text ?? null; + } + } + return null; +} + +/** Extract controller class name from arguments: [Controller::class, 'method'] or 'Controller@method' */ +function extractControllerTarget(argsNode: any): { controller: string | null; method: string | null } { + if (!argsNode) return { controller: null, method: null }; + + const args: any[] = []; + for (const child of argsNode.children ?? []) { + if (child.type === 'argument') args.push(child.children?.[0]); + else if (child.type !== '(' && child.type !== ')' && child.type !== ',') args.push(child); + } + + // Second arg is the handler + const handlerNode = args[1]; + if (!handlerNode) return { controller: null, method: null }; + + // Array syntax: [UserController::class, 'index'] + if (handlerNode.type === 'array_creation_expression') { + let controller: string | null = null; + let method: string | null = null; + const elements: any[] = []; + for (const el of handlerNode.children ?? []) { + if (el.type === 'array_element_initializer') elements.push(el); + } + if (elements[0]) { + const classAccess = findDescendant(elements[0], 'class_constant_access_expression'); + if (classAccess) { + controller = classAccess.children?.find((c: any) => c.type === 'name')?.text ?? null; + } + } + if (elements[1]) { + const str = findDescendant(elements[1], 'string'); + method = str ? extractStringContent(str) : null; + } + return { controller, method }; + } + + // String syntax: 'UserController@index' + if (handlerNode.type === 'string' || handlerNode.type === 'encapsed_string') { + const text = extractStringContent(handlerNode); + if (text?.includes('@')) { + const [controller, method] = text.split('@'); + return { controller, method }; + } + } + + // Class reference: UserController::class (invokable controller) + if (handlerNode.type === 'class_constant_access_expression') { + const controller = handlerNode.children?.find((c: any) => c.type === 'name')?.text ?? null; + return { controller, method: '__invoke' }; + } + + return { controller: null, method: null }; +} + +interface ChainedRouteCall { + isRouteFacade: boolean; + terminalMethod: string; + attributes: { method: string; argsNode: any }[]; + terminalArgs: any; + node: any; +} + +/** + * Unwrap a chained call like Route::middleware('auth')->prefix('api')->group(fn) + */ +function unwrapRouteChain(node: any): ChainedRouteCall | null { + if (node.type !== 'member_call_expression') return null; + + const terminalMethod = getCallMethodName(node); + if (!terminalMethod) return null; + + const terminalArgs = getArguments(node); + const attributes: { method: string; argsNode: any }[] = []; + + let current = node.children?.[0]; + + while (current) { + if (current.type === 'member_call_expression') { + const method = getCallMethodName(current); + const args = getArguments(current); + if (method) attributes.unshift({ method, argsNode: args }); + current = current.children?.[0]; + } else if (current.type === 'scoped_call_expression') { + const obj = current.childForFieldName?.('object') ?? current.children?.[0]; + if (obj?.text !== 'Route') return null; + + const method = getCallMethodName(current); + const args = getArguments(current); + if (method) attributes.unshift({ method, argsNode: args }); + + return { isRouteFacade: true, terminalMethod, attributes, terminalArgs, node }; + } else { + break; + } + } + + return null; +} + +/** Parse Route::group(['middleware' => ..., 'prefix' => ...], fn) array syntax */ +function parseArrayGroupArgs(argsNode: any): RouteGroupContext { + const ctx: RouteGroupContext = { middleware: [], prefix: null, controller: null }; + if (!argsNode) return ctx; + + for (const child of argsNode.children ?? []) { + const target = child.type === 'argument' ? child.children?.[0] : child; + if (target?.type === 'array_creation_expression') { + for (const el of target.children ?? []) { + if (el.type !== 'array_element_initializer') continue; + const children = el.children ?? []; + const arrowIdx = children.findIndex((c: any) => c.type === '=>'); + if (arrowIdx === -1) continue; + const key = extractStringContent(children[arrowIdx - 1]); + const val = children[arrowIdx + 1]; + if (key === 'middleware') { + if (val?.type === 'string') { + const s = extractStringContent(val); + if (s) ctx.middleware.push(s); + } else if (val?.type === 'array_creation_expression') { + for (const item of val.children ?? []) { + if (item.type === 'array_element_initializer') { + const str = item.children?.find((c: any) => c.type === 'string'); + const s = str ? extractStringContent(str) : null; + if (s) ctx.middleware.push(s); + } + } + } + } else if (key === 'prefix') { + ctx.prefix = extractStringContent(val) ?? null; + } else if (key === 'controller') { + if (val?.type === 'class_constant_access_expression') { + ctx.controller = val.children?.find((c: any) => c.type === 'name')?.text ?? null; + } + } + } + } + } + return ctx; +} + +function extractLaravelRoutes(tree: any, filePath: string): ExtractedRoute[] { + const routes: ExtractedRoute[] = []; + + function resolveStack(stack: RouteGroupContext[]): { middleware: string[]; prefix: string | null; controller: string | null } { + const middleware: string[] = []; + let prefix: string | null = null; + let controller: string | null = null; + for (const ctx of stack) { + middleware.push(...ctx.middleware); + if (ctx.prefix) prefix = prefix ? `${prefix}/${ctx.prefix}`.replace(/\/+/g, '/') : ctx.prefix; + if (ctx.controller) controller = ctx.controller; + } + return { middleware, prefix, controller }; + } + + function emitRoute( + httpMethod: string, + argsNode: any, + lineNumber: number, + groupStack: RouteGroupContext[], + chainAttrs: { method: string; argsNode: any }[], + ) { + const effective = resolveStack(groupStack); + + for (const attr of chainAttrs) { + if (attr.method === 'middleware') effective.middleware.push(...extractMiddlewareArg(attr.argsNode)); + if (attr.method === 'prefix') { + const p = extractFirstStringArg(attr.argsNode); + if (p) effective.prefix = effective.prefix ? `${effective.prefix}/${p}` : p; + } + if (attr.method === 'controller') { + const cls = extractClassArg(attr.argsNode); + if (cls) effective.controller = cls; + } + } + + const routePath = extractFirstStringArg(argsNode); + + if (ROUTE_RESOURCE_METHODS.has(httpMethod)) { + const target = extractControllerTarget(argsNode); + const actions = httpMethod === 'apiResource' ? API_RESOURCE_ACTIONS : RESOURCE_ACTIONS; + for (const action of actions) { + routes.push({ + filePath, httpMethod, routePath, + controllerName: target.controller ?? effective.controller, + methodName: action, + middleware: [...effective.middleware], + prefix: effective.prefix, + lineNumber, + }); + } + } else { + const target = extractControllerTarget(argsNode); + routes.push({ + filePath, httpMethod, routePath, + controllerName: target.controller ?? effective.controller, + methodName: target.method, + middleware: [...effective.middleware], + prefix: effective.prefix, + lineNumber, + }); + } + } + + function walk(node: any, groupStack: RouteGroupContext[]) { + // Case 1: Simple Route::get(...), Route::post(...), etc. + if (isRouteStaticCall(node)) { + const method = getCallMethodName(node); + if (method && (ROUTE_HTTP_METHODS.has(method) || ROUTE_RESOURCE_METHODS.has(method))) { + emitRoute(method, getArguments(node), node.startPosition.row, groupStack, []); + return; + } + if (method === 'group') { + const argsNode = getArguments(node); + const groupCtx = parseArrayGroupArgs(argsNode); + const body = findClosureBody(argsNode); + if (body) { + groupStack.push(groupCtx); + walkChildren(body, groupStack); + groupStack.pop(); + } + return; + } + } + + // Case 2: Fluent chain — Route::middleware(...)->group(...) or Route::middleware(...)->get(...) + const chain = unwrapRouteChain(node); + if (chain) { + if (chain.terminalMethod === 'group') { + const groupCtx: RouteGroupContext = { middleware: [], prefix: null, controller: null }; + for (const attr of chain.attributes) { + if (attr.method === 'middleware') groupCtx.middleware.push(...extractMiddlewareArg(attr.argsNode)); + if (attr.method === 'prefix') groupCtx.prefix = extractFirstStringArg(attr.argsNode); + if (attr.method === 'controller') groupCtx.controller = extractClassArg(attr.argsNode); + } + const body = findClosureBody(chain.terminalArgs); + if (body) { + groupStack.push(groupCtx); + walkChildren(body, groupStack); + groupStack.pop(); + } + return; + } + if (ROUTE_HTTP_METHODS.has(chain.terminalMethod) || ROUTE_RESOURCE_METHODS.has(chain.terminalMethod)) { + emitRoute(chain.terminalMethod, chain.terminalArgs, node.startPosition.row, groupStack, chain.attributes); + return; + } + } + + // Default: recurse into children + walkChildren(node, groupStack); + } + + function walkChildren(node: any, groupStack: RouteGroupContext[]) { + for (const child of node.children ?? []) { + walk(child, groupStack); + } + } + + walk(tree.rootNode, []); + return routes; +} + const processFileGroup = ( files: ParseWorkerInput[], language: SupportedLanguages, @@ -397,28 +865,45 @@ const processFileGroup = ( try { const lang = parser.getLanguage(); query = new Parser.Query(lang, queryString); - } catch { + } catch (err) { + const message = `Query compilation failed for ${language}: ${err instanceof Error ? err.message : String(err)}`; + if (parentPort) { + parentPort.postMessage({ type: 'warning', message }); + } else { + console.warn(message); + } return; } for (const file of files) { - // Skip very large files — they can crash tree-sitter or cause OOM - if (file.content.length > 512 * 1024) continue; + // Skip files larger than the max tree-sitter buffer (32 MB) + if (file.content.length > TREE_SITTER_MAX_BUFFER) continue; let tree; try { - tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 }); - } catch { + tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) }); + } catch (err) { + console.warn(`Failed to parse file ${file.path}: ${err instanceof Error ? err.message : String(err)}`); continue; } result.fileCount++; onFileProcessed?.(); + // Build per-file type environment + constructor bindings in a single AST walk. + // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted. + const typeEnv = buildTypeEnv(tree, language); + const callRouter = callRouters[language]; + + if (typeEnv.constructorBindings.length > 0) { + result.constructorBindings.push({ filePath: file.path, bindings: [...typeEnv.constructorBindings] }); + } + let matches; try { matches = query.matches(tree.rootNode); - } catch { + } catch (err) { + console.warn(`Query execution failed for ${file.path}: ${err instanceof Error ? err.message : String(err)}`); continue; } @@ -430,25 +915,163 @@ const processFileGroup = ( // Extract import paths before skipping if (captureMap['import'] && captureMap['import.source']) { - const rawImportPath = captureMap['import.source'].text.replace(/['"<>]/g, ''); + const rawImportPath = language === SupportedLanguages.Kotlin + ? appendKotlinWildcard(captureMap['import.source'].text.replace(/['"<>]/g, ''), captureMap['import']) + : captureMap['import.source'].text.replace(/['"<>]/g, ''); + const namedBindings = extractNamedBindings(captureMap['import'], language); result.imports.push({ filePath: file.path, rawImportPath, language: language, + ...(namedBindings ? { namedBindings } : {}), }); continue; } + // Extract assignment sites (field write access) + if (captureMap['assignment'] && captureMap['assignment.receiver'] && captureMap['assignment.property']) { + const receiverText = captureMap['assignment.receiver'].text; + const propertyName = captureMap['assignment.property'].text; + if (receiverText && propertyName) { + const srcId = findEnclosingFunctionId(captureMap['assignment'], file.path) + || generateId('File', file.path); + let receiverTypeName: string | undefined; + if (typeEnv) { + receiverTypeName = typeEnv.lookup(receiverText, captureMap['assignment']) ?? undefined; + } + result.assignments.push({ + filePath: file.path, + sourceId: srcId, + receiverText, + propertyName, + ...(receiverTypeName ? { receiverTypeName } : {}), + }); + } + if (!captureMap['call']) continue; + } + // Extract call sites if (captureMap['call']) { const callNameNode = captureMap['call.name']; if (callNameNode) { const calledName = callNameNode.text; - if (!BUILT_INS.has(calledName)) { + + // Dispatch: route language-specific calls (heritage, properties, imports) + const routed = callRouter(calledName, captureMap['call']); + if (routed) { + if (routed.kind === 'skip') continue; + + if (routed.kind === 'import') { + result.imports.push({ + filePath: file.path, + rawImportPath: routed.importPath, + language, + }); + continue; + } + + if (routed.kind === 'heritage') { + for (const item of routed.items) { + result.heritage.push({ + filePath: file.path, + className: item.enclosingClass, + parentName: item.mixinName, + kind: item.heritageKind, + }); + } + continue; + } + + if (routed.kind === 'properties') { + const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path); + for (const item of routed.items) { + const nodeId = generateId('Property', `${file.path}:${item.propName}`); + result.nodes.push({ + id: nodeId, + label: 'Property', + properties: { + name: item.propName, + filePath: file.path, + startLine: item.startLine, + endLine: item.endLine, + language, + isExported: true, + description: item.accessorType, + }, + }); + result.symbols.push({ + filePath: file.path, + name: item.propName, + nodeId, + type: 'Property', + ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}), + ...(item.declaredType ? { declaredType: item.declaredType } : {}), + }); + const fileId = generateId('File', file.path); + const relId = generateId('DEFINES', `${fileId}->${nodeId}`); + result.relationships.push({ + id: relId, + sourceId: fileId, + targetId: nodeId, + type: 'DEFINES', + confidence: 1.0, + reason: '', + }); + if (propEnclosingClassId) { + result.relationships.push({ + id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`), + sourceId: propEnclosingClassId, + targetId: nodeId, + type: 'HAS_PROPERTY', + confidence: 1.0, + reason: '', + }); + } + } + continue; + } + + // kind === 'call' — fall through to normal call processing below + } + + if (!isBuiltInOrNoise(calledName)) { const callNode = captureMap['call']; const sourceId = findEnclosingFunctionId(callNode, file.path) || generateId('File', file.path); - result.calls.push({ filePath: file.path, calledName, sourceId }); + const callForm = inferCallForm(callNode, callNameNode); + let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined; + let receiverTypeName = receiverName ? typeEnv.lookup(receiverName, callNode) : undefined; + let receiverMixedChain: MixedChainStep[] | undefined; + + // When the receiver is a complex expression (call chain, field chain, or mixed), + // extractReceiverName returns undefined. Walk the receiver node to build a unified + // mixed chain for deferred resolution in processCallsFromExtracted. + if (callForm === 'member' && receiverName === undefined && !receiverTypeName) { + const receiverNode = extractReceiverNode(callNameNode); + if (receiverNode) { + const extracted = extractMixedChain(receiverNode); + if (extracted && extracted.chain.length > 0) { + receiverMixedChain = extracted.chain; + receiverName = extracted.baseReceiverName; + // Try the type environment immediately for the base receiver + // (covers explicitly-typed locals and annotated parameters). + if (receiverName) { + receiverTypeName = typeEnv.lookup(receiverName, callNode); + } + } + } + } + + result.calls.push({ + filePath: file.path, + calledName, + sourceId, + argCount: countCallArguments(callNode), + ...(callForm !== undefined ? { callForm } : {}), + ...(receiverName !== undefined ? { receiverName } : {}), + ...(receiverTypeName !== undefined ? { receiverTypeName } : {}), + ...(receiverMixedChain !== undefined ? { receiverMixedChain } : {}), + }); } } continue; @@ -457,12 +1080,21 @@ const processFileGroup = ( // Extract heritage (extends/implements) if (captureMap['heritage.class']) { if (captureMap['heritage.extends']) { - result.heritage.push({ - filePath: file.path, - className: captureMap['heritage.class'].text, - parentName: captureMap['heritage.extends'].text, - kind: 'extends', - }); + // Go struct embedding: the query matches ALL field_declarations with + // type_identifier, but only anonymous fields (no name) are embedded. + // Named fields like `Breed string` also match — skip them. + const extendsNode = captureMap['heritage.extends']; + const fieldDecl = extendsNode.parent; + const isNamedField = fieldDecl?.type === 'field_declaration' + && fieldDecl.childForFieldName('name'); + if (!isNamedField) { + result.heritage.push({ + filePath: file.path, + className: captureMap['heritage.class'].text, + parentName: captureMap['heritage.extends'].text, + kind: 'extends', + }); + } } if (captureMap['heritage.implements']) { result.heritage.push({ @@ -488,28 +1120,101 @@ const processFileGroup = ( const nodeLabel = getLabelFromCaptures(captureMap); if (!nodeLabel) continue; + // C/C++: @definition.function is broad and also matches inline class methods (inside + // a class/struct body). Those are already captured by @definition.method, so skip + // the duplicate Function entry to prevent double-indexing in globalIndex. + if ( + (language === SupportedLanguages.CPlusPlus || language === SupportedLanguages.C) && + nodeLabel === 'Function' + ) { + let ancestor = captureMap['definition.function']?.parent; + while (ancestor) { + if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier') { + break; // inside a class body — duplicate of @definition.method + } + ancestor = ancestor.parent; + } + if (ancestor) continue; // found a class/struct ancestor → skip + } + const nameNode = captureMap['name']; - const nodeName = nameNode.text; + // Synthesize name for constructors without explicit @name capture (e.g. Swift init) + if (!nameNode && nodeLabel !== 'Constructor') continue; + const nodeName = nameNode ? nameNode.text : 'init'; + const definitionNode = getDefinitionNodeFromCaptures(captureMap); + const startLine = definitionNode ? definitionNode.startPosition.row : (nameNode ? nameNode.startPosition.row : 0); const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`); + let description: string | undefined; + if (language === SupportedLanguages.PHP) { + if (nodeLabel === 'Property' && captureMap['definition.property']) { + description = extractPhpPropertyDescription(nodeName, captureMap['definition.property']) ?? undefined; + } else if (nodeLabel === 'Method' && captureMap['definition.method']) { + description = extractEloquentRelationDescription(captureMap['definition.method']) ?? undefined; + } + } + + const frameworkHint = definitionNode + ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300)) + : null; + + let parameterCount: number | undefined; + let returnType: string | undefined; + let declaredType: string | undefined; + if (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor') { + const sig = extractMethodSignature(definitionNode); + parameterCount = sig.parameterCount; + returnType = sig.returnType; + + // Language-specific return type fallback (e.g. Ruby YARD @return [Type]) + // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]` + if ((!returnType || returnType === 'array' || returnType === 'iterable') && definitionNode) { + const tc = typeConfigs[language as keyof typeof typeConfigs]; + if (tc?.extractReturnType) { + const docReturn = tc.extractReturnType(definitionNode); + if (docReturn) returnType = docReturn; + } + } + } else if (nodeLabel === 'Property' && definitionNode) { + // Extract the declared type for property/field nodes. + // Walk the definition node for type annotation children. + declaredType = extractPropertyDeclaredType(definitionNode); + } + result.nodes.push({ id: nodeId, label: nodeLabel, properties: { name: nodeName, filePath: file.path, - startLine: nameNode.startPosition.row, - endLine: nameNode.endPosition.row, + startLine: definitionNode ? definitionNode.startPosition.row : startLine, + endLine: definitionNode ? definitionNode.endPosition.row : startLine, language: language, - isExported: isNodeExported(nameNode, nodeName, language), + isExported: isNodeExported(nameNode || definitionNode, nodeName, language), + ...(frameworkHint ? { + astFrameworkMultiplier: frameworkHint.entryPointMultiplier, + astFrameworkReason: frameworkHint.reason, + } : {}), + ...(description !== undefined ? { description } : {}), + ...(parameterCount !== undefined ? { parameterCount } : {}), + ...(returnType !== undefined ? { returnType } : {}), }, }); + // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD + // Function is included because Kotlin/Rust/Python capture class methods as Function nodes + const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function'; + const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNode, file.path) : null; + result.symbols.push({ filePath: file.path, name: nodeName, nodeId, type: nodeLabel, + ...(parameterCount !== undefined ? { parameterCount } : {}), + ...(returnType !== undefined ? { returnType } : {}), + ...(declaredType !== undefined ? { declaredType } : {}), + ...(enclosingClassId ? { ownerId: enclosingClassId } : {}), }); const fileId = generateId('File', file.path); @@ -522,20 +1227,87 @@ const processFileGroup = ( confidence: 1.0, reason: '', }); + + // ── HAS_METHOD / HAS_PROPERTY: link member to enclosing class ── + if (enclosingClassId) { + const memberEdgeType = nodeLabel === 'Property' ? 'HAS_PROPERTY' : 'HAS_METHOD'; + result.relationships.push({ + id: generateId(memberEdgeType, `${enclosingClassId}->${nodeId}`), + sourceId: enclosingClassId, + targetId: nodeId, + type: memberEdgeType, + confidence: 1.0, + reason: '', + }); + } + } + + // Extract Laravel routes from route files via procedural AST walk + if (language === SupportedLanguages.PHP && (file.path.includes('/routes/') || file.path.startsWith('routes/')) && file.path.endsWith('.php')) { + const extractedRoutes = extractLaravelRoutes(tree, file.path); + result.routes.push(...extractedRoutes); } } }; // ============================================================================ -// Worker message handler +// Worker message handler — supports sub-batch streaming // ============================================================================ -parentPort!.on('message', (files: ParseWorkerInput[]) => { +/** Accumulated result across sub-batches */ +let accumulated: ParseWorkerResult = { + nodes: [], relationships: [], symbols: [], + imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0, +}; +let cumulativeProcessed = 0; + +const mergeResult = (target: ParseWorkerResult, src: ParseWorkerResult) => { + target.nodes.push(...src.nodes); + target.relationships.push(...src.relationships); + target.symbols.push(...src.symbols); + target.imports.push(...src.imports); + target.calls.push(...src.calls); + target.assignments.push(...src.assignments); + target.heritage.push(...src.heritage); + target.routes.push(...src.routes); + target.constructorBindings.push(...src.constructorBindings); + for (const [lang, count] of Object.entries(src.skippedLanguages)) { + target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count; + } + target.fileCount += src.fileCount; +}; + +parentPort!.on('message', (msg: any) => { try { - const result = processBatch(files, (filesProcessed) => { - parentPort!.postMessage({ type: 'progress', filesProcessed }); - }); - parentPort!.postMessage({ type: 'result', data: result }); + // Sub-batch mode: { type: 'sub-batch', files: [...] } + if (msg && msg.type === 'sub-batch') { + const result = processBatch(msg.files, (filesProcessed) => { + parentPort!.postMessage({ type: 'progress', filesProcessed: cumulativeProcessed + filesProcessed }); + }); + cumulativeProcessed += result.fileCount; + mergeResult(accumulated, result); + // Signal ready for next sub-batch + parentPort!.postMessage({ type: 'sub-batch-done' }); + return; + } + + // Flush: send accumulated results + if (msg && msg.type === 'flush') { + parentPort!.postMessage({ type: 'result', data: accumulated }); + // Reset for potential reuse + accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 }; + cumulativeProcessed = 0; + return; + } + + // Legacy single-message mode (backward compat): array of files + if (Array.isArray(msg)) { + const result = processBatch(msg, (filesProcessed) => { + parentPort!.postMessage({ type: 'progress', filesProcessed }); + }); + parentPort!.postMessage({ type: 'result', data: result }); + return; + } } catch (err) { const message = err instanceof Error ? err.message : String(err); parentPort!.postMessage({ type: 'error', error: message }); diff --git a/gitnexus/src/core/ingestion/workers/worker-pool.ts b/gitnexus/src/core/ingestion/workers/worker-pool.ts index 5c548dd75c..3f0006370a 100644 --- a/gitnexus/src/core/ingestion/workers/worker-pool.ts +++ b/gitnexus/src/core/ingestion/workers/worker-pool.ts @@ -1,32 +1,45 @@ import { Worker } from 'node:worker_threads'; import os from 'node:os'; +import fs from 'node:fs'; +import { fileURLToPath } from 'node:url'; export interface WorkerPool { /** * Dispatch items across workers. Items are split into chunks (one per worker), - * each worker processes its chunk, and results are concatenated back in order. - * - * @param onProgress - Called with cumulative files processed across all workers + * each worker processes its chunk via sub-batches to limit peak memory, + * and results are concatenated back in order. */ dispatch<TInput, TResult>(items: TInput[], onProgress?: (filesProcessed: number) => void): Promise<TResult[]>; - /** - * Terminate all workers. Must be called when done. - */ + /** Terminate all workers. Must be called when done. */ terminate(): Promise<void>; /** Number of workers in the pool */ readonly size: number; } +/** + * Max files to send to a worker in a single postMessage. + * Keeps structured-clone memory bounded per sub-batch. + */ +const SUB_BATCH_SIZE = 1500; + +/** Per sub-batch timeout. If a single sub-batch takes longer than this, + * likely a pathological file (e.g. minified 50MB JS). Fail fast. */ +const SUB_BATCH_TIMEOUT_MS = 30_000; + /** * Create a pool of worker threads. - * - * @param workerUrl - URL to the worker script (use `new URL('./parse-worker.js', import.meta.url)`) - * @param poolSize - Number of workers (defaults to cpus - 1, minimum 1) */ export const createWorkerPool = (workerUrl: URL, poolSize?: number): WorkerPool => { - const size = poolSize ?? Math.max(1, os.cpus().length - 1); + // Validate worker script exists before spawning to prevent uncaught + // MODULE_NOT_FOUND crashes in worker threads (e.g. when running from src/ via vitest) + const workerPath = fileURLToPath(workerUrl); + if (!fs.existsSync(workerPath)) { + throw new Error(`Worker script not found: ${workerPath}`); + } + + const size = poolSize ?? Math.min(8, Math.max(1, os.cpus().length - 1)); const workers: Worker[] = []; for (let i = 0; i < size; i++) { @@ -36,35 +49,51 @@ export const createWorkerPool = (workerUrl: URL, poolSize?: number): WorkerPool const dispatch = <TInput, TResult>(items: TInput[], onProgress?: (filesProcessed: number) => void): Promise<TResult[]> => { if (items.length === 0) return Promise.resolve([]); - // Split items into one chunk per worker const chunkSize = Math.ceil(items.length / size); const chunks: TInput[][] = []; for (let i = 0; i < items.length; i += chunkSize) { chunks.push(items.slice(i, i + chunkSize)); } - // Track per-worker progress for cumulative reporting const workerProgress = new Array(chunks.length).fill(0); - // Send one chunk to each worker, collect results const promises = chunks.map((chunk, i) => { const worker = workers[i]; return new Promise<TResult>((resolve, reject) => { let settled = false; + let subBatchTimer: ReturnType<typeof setTimeout> | null = null; + const cleanup = () => { - clearTimeout(timer); + if (subBatchTimer) clearTimeout(subBatchTimer); worker.removeListener('message', handler); worker.removeListener('error', errorHandler); worker.removeListener('exit', exitHandler); }; - const timer = setTimeout(() => { - if (!settled) { - settled = true; - cleanup(); - reject(new Error(`Worker ${i} timed out after 5 minutes (chunk: ${chunk.length} items). Worker may have crashed or is processing too much data.`)); + const resetSubBatchTimer = () => { + if (subBatchTimer) clearTimeout(subBatchTimer); + subBatchTimer = setTimeout(() => { + if (!settled) { + settled = true; + cleanup(); + reject(new Error(`Worker ${i} sub-batch timed out after ${SUB_BATCH_TIMEOUT_MS / 1000}s (chunk: ${chunk.length} items).`)); + } + }, SUB_BATCH_TIMEOUT_MS); + }; + + let subBatchIdx = 0; + + const sendNextSubBatch = () => { + const start = subBatchIdx * SUB_BATCH_SIZE; + if (start >= chunk.length) { + worker.postMessage({ type: 'flush' }); + return; } - }, 5 * 60 * 1000); + const subBatch = chunk.slice(start, start + SUB_BATCH_SIZE); + subBatchIdx++; + resetSubBatchTimer(); + worker.postMessage({ type: 'sub-batch', files: subBatch }); + }; const handler = (msg: any) => { if (settled) return; @@ -74,8 +103,9 @@ export const createWorkerPool = (workerUrl: URL, poolSize?: number): WorkerPool const total = workerProgress.reduce((a, b) => a + b, 0); onProgress(total); } + } else if (msg && msg.type === 'sub-batch-done') { + sendNextSubBatch(); } else if (msg && msg.type === 'error') { - // Error reported by worker via postMessage settled = true; cleanup(); reject(new Error(`Worker ${i} error: ${msg.error}`)); @@ -84,7 +114,6 @@ export const createWorkerPool = (workerUrl: URL, poolSize?: number): WorkerPool cleanup(); resolve(msg.data); } else { - // Legacy: treat any non-typed message as result settled = true; cleanup(); resolve(msg); @@ -92,25 +121,21 @@ export const createWorkerPool = (workerUrl: URL, poolSize?: number): WorkerPool }; const errorHandler = (err: any) => { - if (!settled) { - settled = true; - cleanup(); - reject(err); - } + if (!settled) { settled = true; cleanup(); reject(err); } }; const exitHandler = (code: number) => { if (!settled) { settled = true; cleanup(); - reject(new Error(`Worker ${i} exited unexpectedly with code ${code}. This usually indicates an out-of-memory crash or native addon failure.`)); + reject(new Error(`Worker ${i} exited with code ${code}. Likely OOM or native addon failure.`)); } }; worker.on('message', handler); worker.once('error', errorHandler); worker.once('exit', exitHandler); - worker.postMessage(chunk); + sendNextSubBatch(); }); }); diff --git a/gitnexus/src/core/kuzu/csv-generator.ts b/gitnexus/src/core/kuzu/csv-generator.ts deleted file mode 100644 index 2663095709..0000000000 --- a/gitnexus/src/core/kuzu/csv-generator.ts +++ /dev/null @@ -1,326 +0,0 @@ -/** - * CSV Generator for KuzuDB Hybrid Schema - * - * Generates separate CSV files for each node table and one relation CSV. - * This enables efficient bulk loading via COPY FROM for hybrid schema. - * - * RFC 4180 Compliant: - * - Fields containing commas, double quotes, or newlines are enclosed in double quotes - * - Double quotes within fields are escaped by doubling them ("") - * - All fields are consistently quoted for safety with code content - */ - -import { KnowledgeGraph, GraphNode, NodeLabel } from '../graph/types.js'; -import { NODE_TABLES, NodeTableName } from './schema.js'; - -// ============================================================================ -// CSV ESCAPE UTILITIES -// ============================================================================ - -/** - * Sanitize string to ensure valid UTF-8 and safe CSV content for KuzuDB - * Removes or replaces invalid characters that would break CSV parsing. - * - * Critical: KuzuDB's native CSV parser on Windows can misinterpret \r\n - * inside quoted fields. We normalize all line endings to \n only. - */ -const sanitizeUTF8 = (str: string): string => { - return str - .replace(/\r\n/g, '\n') // Normalize Windows line endings first - .replace(/\r/g, '\n') // Normalize remaining \r to \n - .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '') // Remove control chars except \t \n - .replace(/[\uD800-\uDFFF]/g, '') // Remove surrogate pairs (invalid standalone) - .replace(/[\uFFFE\uFFFF]/g, ''); // Remove BOM and special chars -}; - -/** - * RFC 4180 compliant CSV field escaping - * ALWAYS wraps in double quotes for safety with code content - */ -const escapeCSVField = (value: string | number | undefined | null): string => { - if (value === undefined || value === null) { - return '""'; - } - let str = String(value); - str = sanitizeUTF8(str); - return `"${str.replace(/"/g, '""')}"`; -}; - -/** - * Escape a numeric value (no quotes needed for numbers) - */ -const escapeCSVNumber = (value: number | undefined | null, defaultValue: number = -1): string => { - if (value === undefined || value === null) { - return String(defaultValue); - } - return String(value); -}; - -// ============================================================================ -// CONTENT EXTRACTION -// ============================================================================ - -/** - * Check if content looks like binary data - */ -const isBinaryContent = (content: string): boolean => { - if (!content || content.length === 0) return false; - const sample = content.slice(0, 1000); - let nonPrintable = 0; - for (let i = 0; i < sample.length; i++) { - const code = sample.charCodeAt(i); - if ((code < 9) || (code > 13 && code < 32) || code === 127) { - nonPrintable++; - } - } - return (nonPrintable / sample.length) > 0.1; -}; - -/** - * Extract code content for a node - */ -const extractContent = ( - node: GraphNode, - fileContents: Map<string, string> -): string => { - const filePath = node.properties.filePath; - const content = fileContents.get(filePath); - - if (!content) return ''; - if (node.label === 'Folder') return ''; - if (isBinaryContent(content)) return '[Binary file - content not stored]'; - - // For File nodes, return content (limited) - if (node.label === 'File') { - const MAX_FILE_CONTENT = 10000; - if (content.length > MAX_FILE_CONTENT) { - return content.slice(0, MAX_FILE_CONTENT) + '\n... [truncated]'; - } - return content; - } - - // For code elements, extract the relevant lines with context - const startLine = node.properties.startLine; - const endLine = node.properties.endLine; - - if (startLine === undefined || endLine === undefined) return ''; - - const lines = content.split('\n'); - const contextLines = 2; - const start = Math.max(0, startLine - contextLines); - const end = Math.min(lines.length - 1, endLine + contextLines); - - const snippet = lines.slice(start, end + 1).join('\n'); - const MAX_SNIPPET = 5000; - if (snippet.length > MAX_SNIPPET) { - return snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]'; - } - return snippet; -}; - -// ============================================================================ -// CSV GENERATION RESULT TYPE -// ============================================================================ - -export interface CSVData { - nodes: Map<NodeTableName, string>; - relCSV: string; // Single relation CSV with from,to,type,confidence,reason columns -} - -// ============================================================================ -// NODE CSV GENERATORS -// ============================================================================ - -/** - * Generate CSV for File nodes - * Headers: id,name,filePath,content - */ -const generateFileCSV = (nodes: GraphNode[], fileContents: Map<string, string>): string => { - const headers = ['id', 'name', 'filePath', 'content']; - const rows: string[] = [headers.join(',')]; - const seenIds = new Set<string>(); - - for (const node of nodes) { - if (node.label !== 'File') continue; - // Skip duplicates - if (seenIds.has(node.id)) continue; - seenIds.add(node.id); - - const content = extractContent(node, fileContents); - rows.push([ - escapeCSVField(node.id), - escapeCSVField(node.properties.name || ''), - escapeCSVField(node.properties.filePath || ''), - escapeCSVField(content), - ].join(',')); - } - - return rows.join('\n'); -}; - -/** - * Generate CSV for Folder nodes - * Headers: id,name,filePath - */ -const generateFolderCSV = (nodes: GraphNode[]): string => { - const headers = ['id', 'name', 'filePath']; - const rows: string[] = [headers.join(',')]; - - for (const node of nodes) { - if (node.label !== 'Folder') continue; - rows.push([ - escapeCSVField(node.id), - escapeCSVField(node.properties.name || ''), - escapeCSVField(node.properties.filePath || ''), - ].join(',')); - } - - return rows.join('\n'); -}; - -/** - * Generate CSV for code element nodes (Function, Class, Interface, Method, CodeElement) - * Headers: id,name,filePath,startLine,endLine,isExported,content - */ -const generateCodeElementCSV = ( - nodes: GraphNode[], - label: NodeLabel, - fileContents: Map<string, string> -): string => { - const headers = ['id', 'name', 'filePath', 'startLine', 'endLine', 'isExported', 'content']; - const rows: string[] = [headers.join(',')]; - - for (const node of nodes) { - if (node.label !== label) continue; - const content = extractContent(node, fileContents); - rows.push([ - escapeCSVField(node.id), - escapeCSVField(node.properties.name || ''), - escapeCSVField(node.properties.filePath || ''), - escapeCSVNumber(node.properties.startLine, -1), - escapeCSVNumber(node.properties.endLine, -1), - node.properties.isExported ? 'true' : 'false', - escapeCSVField(content), - ].join(',')); - } - - return rows.join('\n'); -}; - -/** - * Generate CSV for Community nodes (from Leiden algorithm) - * Headers: id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount - */ -const generateCommunityCSV = (nodes: GraphNode[]): string => { - const headers = ['id', 'label', 'heuristicLabel', 'keywords', 'description', 'enrichedBy', 'cohesion', 'symbolCount']; - const rows: string[] = [headers.join(',')]; - - for (const node of nodes) { - if (node.label !== 'Community') continue; - - // Handle keywords array - convert to KuzuDB array format - const keywords = (node.properties as any).keywords || []; - const keywordsStr = `[${keywords.map((k: string) => `'${k.replace(/'/g, "''")}'`).join(',')}]`; - - rows.push([ - escapeCSVField(node.id), - escapeCSVField(node.properties.name || ''), // label is stored in name - escapeCSVField(node.properties.heuristicLabel || ''), - keywordsStr, // Array format for KuzuDB - escapeCSVField((node.properties as any).description || ''), - escapeCSVField((node.properties as any).enrichedBy || 'heuristic'), - escapeCSVNumber(node.properties.cohesion, 0), - escapeCSVNumber(node.properties.symbolCount, 0), - ].join(',')); - } - - return rows.join('\n'); -}; - -/** - * Generate CSV for Process nodes - * Headers: id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId - */ -const generateProcessCSV = (nodes: GraphNode[]): string => { - const headers = ['id', 'label', 'heuristicLabel', 'processType', 'stepCount', 'communities', 'entryPointId', 'terminalId']; - const rows: string[] = [headers.join(',')]; - - for (const node of nodes) { - if (node.label !== 'Process') continue; - - // Handle communities array (string[]) - const communities = (node.properties as any).communities || []; - const communitiesStr = `[${communities.map((c: string) => `'${c.replace(/'/g, "''")}'`).join(',')}]`; - - rows.push([ - escapeCSVField(node.id), - escapeCSVField(node.properties.name || ''), // label stores name - escapeCSVField((node.properties as any).heuristicLabel || ''), - escapeCSVField((node.properties as any).processType || ''), - escapeCSVNumber((node.properties as any).stepCount, 0), - escapeCSVField(communitiesStr), // Needs CSV escaping because it contains commas! - escapeCSVField((node.properties as any).entryPointId || ''), - escapeCSVField((node.properties as any).terminalId || ''), - ].join(',')); - } - - return rows.join('\n'); -}; - -/** - * Generate CSV for the single CodeRelation table - * Headers: from,to,type,confidence,reason - * - * confidence: 0-1 score for CALLS edges (how sure are we about the target?) - * reason: 'import-resolved' | 'same-file' | 'fuzzy-global' (or empty for non-CALLS) - */ -const generateRelationCSV = (graph: KnowledgeGraph): string => { - const headers = ['from', 'to', 'type', 'confidence', 'reason', 'step']; - const rows: string[] = [headers.join(',')]; - - for (const rel of graph.relationships) { - rows.push([ - escapeCSVField(rel.sourceId), - escapeCSVField(rel.targetId), - escapeCSVField(rel.type), - escapeCSVNumber(rel.confidence, 1.0), - escapeCSVField(rel.reason), - escapeCSVNumber((rel as any).step, 0), - ].join(',')); - } - - return rows.join('\n'); -}; - -// ============================================================================ -// MAIN CSV GENERATION FUNCTION -// ============================================================================ - -/** - * Generate all CSV data for hybrid schema bulk loading - * Returns Maps of node table name -> CSV content, and single relation CSV - */ -export const generateAllCSVs = ( - graph: KnowledgeGraph, - fileContents: Map<string, string> -): CSVData => { - const nodes = Array.from(graph.nodes); - - // Generate node CSVs - const nodeCSVs = new Map<NodeTableName, string>(); - nodeCSVs.set('File', generateFileCSV(nodes, fileContents)); - nodeCSVs.set('Folder', generateFolderCSV(nodes)); - nodeCSVs.set('Function', generateCodeElementCSV(nodes, 'Function', fileContents)); - nodeCSVs.set('Class', generateCodeElementCSV(nodes, 'Class', fileContents)); - nodeCSVs.set('Interface', generateCodeElementCSV(nodes, 'Interface', fileContents)); - nodeCSVs.set('Method', generateCodeElementCSV(nodes, 'Method', fileContents)); - nodeCSVs.set('CodeElement', generateCodeElementCSV(nodes, 'CodeElement', fileContents)); - nodeCSVs.set('Community', generateCommunityCSV(nodes)); - nodeCSVs.set('Process', generateProcessCSV(nodes)); - - // Generate single relation CSV - const relCSV = generateRelationCSV(graph); - - return { nodes: nodeCSVs, relCSV }; -}; - diff --git a/gitnexus/src/core/lbug/csv-generator.ts b/gitnexus/src/core/lbug/csv-generator.ts new file mode 100644 index 0000000000..9c99eb04b2 --- /dev/null +++ b/gitnexus/src/core/lbug/csv-generator.ts @@ -0,0 +1,402 @@ +/** + * CSV Generator for LadybugDB Hybrid Schema + * + * Streams CSV rows directly to disk files in a single pass over graph nodes. + * File contents are lazy-read from disk per-node to avoid holding the entire + * repo in RAM. Rows are buffered (FLUSH_EVERY) before writing to minimize + * per-row Promise overhead. + * + * RFC 4180 Compliant: + * - Fields containing commas, double quotes, or newlines are enclosed in double quotes + * - Double quotes within fields are escaped by doubling them ("") + * - All fields are consistently quoted for safety with code content + */ + +import fs from 'fs/promises'; +import { createWriteStream, WriteStream } from 'fs'; +import path from 'path'; +import { KnowledgeGraph, GraphNode, NodeLabel } from '../graph/types.js'; +import { NodeTableName } from './schema.js'; + +/** Flush buffered rows to disk every N rows */ +const FLUSH_EVERY = 500; + +// ============================================================================ +// CSV ESCAPE UTILITIES +// ============================================================================ + +export const sanitizeUTF8 = (str: string): string => { + return str + .replace(/\r\n/g, '\n') + .replace(/\r/g, '\n') + .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '') + .replace(/[\uD800-\uDFFF]/g, '') + .replace(/[\uFFFE\uFFFF]/g, ''); +}; + +export const escapeCSVField = (value: string | number | undefined | null): string => { + if (value === undefined || value === null) return '""'; + let str = String(value); + str = sanitizeUTF8(str); + return `"${str.replace(/"/g, '""')}"`; +}; + +export const escapeCSVNumber = (value: number | undefined | null, defaultValue: number = -1): string => { + if (value === undefined || value === null) return String(defaultValue); + return String(value); +}; + +// ============================================================================ +// CONTENT EXTRACTION (lazy — reads from disk on demand) +// ============================================================================ + +export const isBinaryContent = (content: string): boolean => { + if (!content || content.length === 0) return false; + const sample = content.slice(0, 1000); + let nonPrintable = 0; + for (let i = 0; i < sample.length; i++) { + const code = sample.charCodeAt(i); + if ((code < 9) || (code > 13 && code < 32) || code === 127) nonPrintable++; + } + return (nonPrintable / sample.length) > 0.1; +}; + +/** + * LRU content cache — avoids re-reading the same source file for every + * symbol defined in it. Sized generously so most files stay cached during + * the single-pass node iteration. + */ +class FileContentCache { + private cache = new Map<string, string>(); + private accessOrder: string[] = []; + private maxSize: number; + private repoPath: string; + + constructor(repoPath: string, maxSize: number = 3000) { + this.repoPath = repoPath; + this.maxSize = maxSize; + } + + async get(relativePath: string): Promise<string> { + if (!relativePath) return ''; + const cached = this.cache.get(relativePath); + if (cached !== undefined) { + // Move to end of accessOrder (LRU promotion) + const idx = this.accessOrder.indexOf(relativePath); + if (idx !== -1) { + this.accessOrder.splice(idx, 1); + this.accessOrder.push(relativePath); + } + return cached; + } + try { + const fullPath = path.join(this.repoPath, relativePath); + const content = await fs.readFile(fullPath, 'utf-8'); + this.set(relativePath, content); + return content; + } catch { + this.set(relativePath, ''); + return ''; + } + } + + private set(key: string, value: string) { + if (this.cache.size >= this.maxSize) { + const oldest = this.accessOrder.shift(); + if (oldest) this.cache.delete(oldest); + } + this.cache.set(key, value); + this.accessOrder.push(key); + } +} + +const extractContent = async ( + node: GraphNode, + contentCache: FileContentCache +): Promise<string> => { + const filePath = node.properties.filePath; + const content = await contentCache.get(filePath); + if (!content) return ''; + if (node.label === 'Folder') return ''; + if (isBinaryContent(content)) return '[Binary file - content not stored]'; + + if (node.label === 'File') { + const MAX_FILE_CONTENT = 10000; + return content.length > MAX_FILE_CONTENT + ? content.slice(0, MAX_FILE_CONTENT) + '\n... [truncated]' + : content; + } + + const startLine = node.properties.startLine; + const endLine = node.properties.endLine; + if (startLine === undefined || endLine === undefined) return ''; + + const lines = content.split('\n'); + const start = Math.max(0, startLine - 2); + const end = Math.min(lines.length - 1, endLine + 2); + const snippet = lines.slice(start, end + 1).join('\n'); + const MAX_SNIPPET = 5000; + return snippet.length > MAX_SNIPPET + ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]' + : snippet; +}; + +// ============================================================================ +// BUFFERED CSV WRITER +// ============================================================================ + +class BufferedCSVWriter { + private ws: WriteStream; + private buffer: string[] = []; + rows = 0; + + constructor(filePath: string, header: string) { + this.ws = createWriteStream(filePath, 'utf-8'); + // Large repos flush many times — raise listener cap to avoid MaxListenersExceededWarning + this.ws.setMaxListeners(50); + this.buffer.push(header); + } + + addRow(row: string) { + this.buffer.push(row); + this.rows++; + if (this.buffer.length >= FLUSH_EVERY) { + return this.flush(); + } + return Promise.resolve(); + } + + flush(): Promise<void> { + if (this.buffer.length === 0) return Promise.resolve(); + const chunk = this.buffer.join('\n') + '\n'; + this.buffer.length = 0; + return new Promise((resolve, reject) => { + this.ws.once('error', reject); + const ok = this.ws.write(chunk); + if (ok) { + this.ws.removeListener('error', reject); + resolve(); + } else { + this.ws.once('drain', () => { + this.ws.removeListener('error', reject); + resolve(); + }); + } + }); + } + + async finish(): Promise<void> { + await this.flush(); + return new Promise((resolve, reject) => { + this.ws.end(() => resolve()); + this.ws.on('error', reject); + }); + } +} + +// ============================================================================ +// STREAMING CSV GENERATION — SINGLE PASS +// ============================================================================ + +export interface StreamedCSVResult { + nodeFiles: Map<NodeTableName, { csvPath: string; rows: number }>; + relCsvPath: string; + relRows: number; +} + +/** + * Stream all CSV data directly to disk files. + * Iterates graph nodes exactly ONCE — routes each node to the right writer. + * File contents are lazy-read from disk with a generous LRU cache. + */ +export const streamAllCSVsToDisk = async ( + graph: KnowledgeGraph, + repoPath: string, + csvDir: string, +): Promise<StreamedCSVResult> => { + // Remove stale CSVs from previous crashed runs, then recreate + try { await fs.rm(csvDir, { recursive: true, force: true }); } catch {} + await fs.mkdir(csvDir, { recursive: true }); + + // We open ~30 concurrent write-streams; raise process limit to suppress + // MaxListenersExceededWarning (restored after all streams finish). + const prevMax = process.getMaxListeners(); + process.setMaxListeners(prevMax + 40); + + const contentCache = new FileContentCache(repoPath); + + // Create writers for every node type up-front + const fileWriter = new BufferedCSVWriter(path.join(csvDir, 'file.csv'), 'id,name,filePath,content'); + const folderWriter = new BufferedCSVWriter(path.join(csvDir, 'folder.csv'), 'id,name,filePath'); + const codeElementHeader = 'id,name,filePath,startLine,endLine,isExported,content,description'; + const functionWriter = new BufferedCSVWriter(path.join(csvDir, 'function.csv'), codeElementHeader); + const classWriter = new BufferedCSVWriter(path.join(csvDir, 'class.csv'), codeElementHeader); + const interfaceWriter = new BufferedCSVWriter(path.join(csvDir, 'interface.csv'), codeElementHeader); + const methodHeader = 'id,name,filePath,startLine,endLine,isExported,content,description,parameterCount,returnType'; + const methodWriter = new BufferedCSVWriter(path.join(csvDir, 'method.csv'), methodHeader); + const codeElemWriter = new BufferedCSVWriter(path.join(csvDir, 'codeelement.csv'), codeElementHeader); + const communityWriter = new BufferedCSVWriter(path.join(csvDir, 'community.csv'), 'id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount'); + const processWriter = new BufferedCSVWriter(path.join(csvDir, 'process.csv'), 'id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId'); + + // Multi-language node types share the same CSV shape (no isExported column) + const multiLangHeader = 'id,name,filePath,startLine,endLine,content,description'; + const MULTI_LANG_TYPES = ['Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl', + 'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module'] as const; + const multiLangWriters = new Map<string, BufferedCSVWriter>(); + for (const t of MULTI_LANG_TYPES) { + multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), multiLangHeader)); + } + + const codeWriterMap: Record<string, BufferedCSVWriter> = { + 'Function': functionWriter, + 'Class': classWriter, + 'Interface': interfaceWriter, + 'CodeElement': codeElemWriter, + }; + + const seenFileIds = new Set<string>(); + + // --- SINGLE PASS over all nodes --- + for (const node of graph.iterNodes()) { + switch (node.label) { + case 'File': { + if (seenFileIds.has(node.id)) break; + seenFileIds.add(node.id); + const content = await extractContent(node, contentCache); + await fileWriter.addRow([ + escapeCSVField(node.id), + escapeCSVField(node.properties.name || ''), + escapeCSVField(node.properties.filePath || ''), + escapeCSVField(content), + ].join(',')); + break; + } + case 'Folder': + await folderWriter.addRow([ + escapeCSVField(node.id), + escapeCSVField(node.properties.name || ''), + escapeCSVField(node.properties.filePath || ''), + ].join(',')); + break; + case 'Community': { + const keywords = (node.properties as any).keywords || []; + const keywordsStr = `[${keywords.map((k: string) => `'${k.replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/,/g, '\\,')}'`).join(',')}]`; + await communityWriter.addRow([ + escapeCSVField(node.id), + escapeCSVField(node.properties.name || ''), + escapeCSVField(node.properties.heuristicLabel || ''), + keywordsStr, + escapeCSVField((node.properties as any).description || ''), + escapeCSVField((node.properties as any).enrichedBy || 'heuristic'), + escapeCSVNumber(node.properties.cohesion, 0), + escapeCSVNumber(node.properties.symbolCount, 0), + ].join(',')); + break; + } + case 'Process': { + const communities = (node.properties as any).communities || []; + const communitiesStr = `[${communities.map((c: string) => `'${c.replace(/'/g, "''")}'`).join(',')}]`; + await processWriter.addRow([ + escapeCSVField(node.id), + escapeCSVField(node.properties.name || ''), + escapeCSVField((node.properties as any).heuristicLabel || ''), + escapeCSVField((node.properties as any).processType || ''), + escapeCSVNumber((node.properties as any).stepCount, 0), + escapeCSVField(communitiesStr), + escapeCSVField((node.properties as any).entryPointId || ''), + escapeCSVField((node.properties as any).terminalId || ''), + ].join(',')); + break; + } + case 'Method': { + const content = await extractContent(node, contentCache); + await methodWriter.addRow([ + escapeCSVField(node.id), + escapeCSVField(node.properties.name || ''), + escapeCSVField(node.properties.filePath || ''), + escapeCSVNumber(node.properties.startLine, -1), + escapeCSVNumber(node.properties.endLine, -1), + node.properties.isExported ? 'true' : 'false', + escapeCSVField(content), + escapeCSVField((node.properties as any).description || ''), + escapeCSVNumber(node.properties.parameterCount, 0), + escapeCSVField(node.properties.returnType || ''), + ].join(',')); + break; + } + default: { + // Code element nodes (Function, Class, Interface, CodeElement) + const writer = codeWriterMap[node.label]; + if (writer) { + const content = await extractContent(node, contentCache); + await writer.addRow([ + escapeCSVField(node.id), + escapeCSVField(node.properties.name || ''), + escapeCSVField(node.properties.filePath || ''), + escapeCSVNumber(node.properties.startLine, -1), + escapeCSVNumber(node.properties.endLine, -1), + node.properties.isExported ? 'true' : 'false', + escapeCSVField(content), + escapeCSVField((node.properties as any).description || ''), + ].join(',')); + } else { + // Multi-language node types (Struct, Impl, Trait, Macro, etc.) + const mlWriter = multiLangWriters.get(node.label); + if (mlWriter) { + const content = await extractContent(node, contentCache); + await mlWriter.addRow([ + escapeCSVField(node.id), + escapeCSVField(node.properties.name || ''), + escapeCSVField(node.properties.filePath || ''), + escapeCSVNumber(node.properties.startLine, -1), + escapeCSVNumber(node.properties.endLine, -1), + escapeCSVField(content), + escapeCSVField((node.properties as any).description || ''), + ].join(',')); + } + } + break; + } + } + } + + // Finish all node writers + const allWriters = [fileWriter, folderWriter, functionWriter, classWriter, interfaceWriter, methodWriter, codeElemWriter, communityWriter, processWriter, ...multiLangWriters.values()]; + await Promise.all(allWriters.map(w => w.finish())); + + // --- Stream relationship CSV --- + const relCsvPath = path.join(csvDir, 'relations.csv'); + const relWriter = new BufferedCSVWriter(relCsvPath, 'from,to,type,confidence,reason,step'); + for (const rel of graph.iterRelationships()) { + await relWriter.addRow([ + escapeCSVField(rel.sourceId), + escapeCSVField(rel.targetId), + escapeCSVField(rel.type), + escapeCSVNumber(rel.confidence, 1.0), + escapeCSVField(rel.reason), + escapeCSVNumber((rel as any).step, 0), + ].join(',')); + } + await relWriter.finish(); + + // Build result map — only include tables that have rows + const nodeFiles = new Map<NodeTableName, { csvPath: string; rows: number }>(); + const tableMap: [NodeTableName, BufferedCSVWriter][] = [ + ['File', fileWriter], ['Folder', folderWriter], + ['Function', functionWriter], ['Class', classWriter], + ['Interface', interfaceWriter], ['Method', methodWriter], + ['CodeElement', codeElemWriter], + ['Community', communityWriter], ['Process', processWriter], + ...Array.from(multiLangWriters.entries()).map(([name, w]) => [name as NodeTableName, w] as [NodeTableName, BufferedCSVWriter]), + ]; + for (const [name, writer] of tableMap) { + if (writer.rows > 0) { + nodeFiles.set(name, { csvPath: path.join(csvDir, `${name.toLowerCase()}.csv`), rows: writer.rows }); + } + } + + // Restore original process listener limit + process.setMaxListeners(prevMax); + + return { nodeFiles, relCsvPath, relRows: relWriter.rows }; +}; diff --git a/gitnexus/src/core/kuzu/kuzu-adapter.ts b/gitnexus/src/core/lbug/lbug-adapter.ts similarity index 63% rename from gitnexus/src/core/kuzu/kuzu-adapter.ts rename to gitnexus/src/core/lbug/lbug-adapter.ts index 9988b56ede..bd40617976 100644 --- a/gitnexus/src/core/kuzu/kuzu-adapter.ts +++ b/gitnexus/src/core/lbug/lbug-adapter.ts @@ -1,6 +1,8 @@ import fs from 'fs/promises'; +import { createReadStream } from 'fs'; +import { createInterface } from 'readline'; import path from 'path'; -import kuzu from 'kuzu'; +import lbug from '@ladybugdb/core'; import { KnowledgeGraph } from '../graph/types.js'; import { NODE_TABLES, @@ -9,42 +11,101 @@ import { EMBEDDING_TABLE_NAME, NodeTableName, } from './schema.js'; -import { generateAllCSVs } from './csv-generator.js'; +import { streamAllCSVsToDisk } from './csv-generator.js'; -let db: kuzu.Database | null = null; -let conn: kuzu.Connection | null = null; +let db: lbug.Database | null = null; +let conn: lbug.Connection | null = null; +let currentDbPath: string | null = null; +let ftsLoaded = false; + +/** Expose the current Database for pool adapter reuse in tests. */ +export const getDatabase = (): lbug.Database | null => db; + +// Global session lock for operations that touch module-level lbug globals. +// This guarantees no DB switch can happen while an operation is running. +let sessionLock: Promise<void> = Promise.resolve(); + +const runWithSessionLock = async <T>(operation: () => Promise<T>): Promise<T> => { + const previous = sessionLock; + let release: (() => void) | null = null; + sessionLock = new Promise<void>(resolve => { + release = resolve; + }); + + await previous; + try { + return await operation(); + } finally { + release?.(); + } +}; const normalizeCopyPath = (filePath: string): string => filePath.replace(/\\/g, '/'); -export const initKuzu = async (dbPath: string) => { - if (conn) return { db, conn }; +export const initLbug = async (dbPath: string) => { + return runWithSessionLock(() => ensureLbugInitialized(dbPath)); +}; - // kuzu v0.11 stores the database as a single file (not a directory). - // If the path already exists, it must be a valid kuzu database file. +/** + * Execute multiple queries against one repo DB atomically. + * While the callback runs, no other request can switch the active DB. + */ +export const withLbugDb = async <T>(dbPath: string, operation: () => Promise<T>): Promise<T> => { + return runWithSessionLock(async () => { + await ensureLbugInitialized(dbPath); + return operation(); + }); +}; + +const ensureLbugInitialized = async (dbPath: string) => { + if (conn && currentDbPath === dbPath) { + return { db, conn }; + } + await doInitLbug(dbPath); + return { db, conn }; +}; + +const doInitLbug = async (dbPath: string) => { + // Different database requested — close the old one first + if (conn || db) { + try { if (conn) await conn.close(); } catch {} + try { if (db) await db.close(); } catch {} + conn = null; + db = null; + currentDbPath = null; + ftsLoaded = false; + } + + // LadybugDB stores the database as a single file (not a directory). + // If the path already exists, it must be a valid LadybugDB database file. // Remove stale empty directories or files from older versions. try { - const stat = await fs.stat(dbPath); - if (stat.isDirectory()) { - // Old-style directory database or empty leftover - remove it - const files = await fs.readdir(dbPath); - if (files.length === 0) { - await fs.rmdir(dbPath); - } else { - // Non-empty directory from older kuzu version - remove entire directory - await fs.rm(dbPath, { recursive: true, force: true }); + const stat = await fs.lstat(dbPath); + if (stat.isSymbolicLink()) { + // Never follow symlinks — just remove the link itself + await fs.unlink(dbPath); + } else if (stat.isDirectory()) { + // Verify path is within expected storage directory before deleting + const realPath = await fs.realpath(dbPath); + const parentDir = path.dirname(dbPath); + const realParent = await fs.realpath(parentDir); + if (!realPath.startsWith(realParent + path.sep) && realPath !== realParent) { + throw new Error(`Refusing to delete ${dbPath}: resolved path ${realPath} is outside storage directory`); } + // Old-style directory database or empty leftover - remove it + await fs.rm(dbPath, { recursive: true, force: true }); } - // If it's a file, assume it's an existing kuzu database - kuzu will open it + // If it's a file, assume it's an existing LadybugDB database - LadybugDB will open it } catch { - // Path doesn't exist, which is what kuzu wants for a new database + // Path doesn't exist, which is what LadybugDB wants for a new database } // Ensure parent directory exists const parentDir = path.dirname(dbPath); await fs.mkdir(parentDir, { recursive: true }); - db = new kuzu.Database(dbPath); - conn = new kuzu.Connection(db); + db = new lbug.Database(dbPath); + conn = new lbug.Connection(db); for (const schemaQuery of SCHEMA_QUERIES) { try { @@ -58,40 +119,29 @@ export const initKuzu = async (dbPath: string) => { } } + currentDbPath = dbPath; return { db, conn }; }; -export type KuzuProgressCallback = (message: string) => void; +export type LbugProgressCallback = (message: string) => void; -export const loadGraphToKuzu = async ( +export const loadGraphToLbug = async ( graph: KnowledgeGraph, - fileContents: Map<string, string>, + repoPath: string, storagePath: string, - onProgress?: KuzuProgressCallback + onProgress?: LbugProgressCallback ) => { if (!conn) { - throw new Error('KuzuDB not initialized. Call initKuzu first.'); + throw new Error('LadybugDB not initialized. Call initLbug first.'); } const log = onProgress || (() => {}); - const csvData = generateAllCSVs(graph, fileContents); const csvDir = path.join(storagePath, 'csv'); - await fs.mkdir(csvDir, { recursive: true }); - log('Generating CSVs...'); + log('Streaming CSVs to disk...'); + const csvResult = await streamAllCSVsToDisk(graph, repoPath, csvDir); - const nodeFiles: Array<{ table: NodeTableName; path: string; rows: number }> = []; - for (const [tableName, csv] of csvData.nodes.entries()) { - const rowCount = csv.split('\n').length - 1; - if (rowCount <= 0) continue; - const filePath = path.join(csvDir, `${tableName.toLowerCase()}.csv`); - await fs.writeFile(filePath, csv, 'utf-8'); - nodeFiles.push({ table: tableName, path: filePath, rows: rowCount }); - } - - // Write relationship CSV to disk for bulk COPY - const relCsvPath = path.join(csvDir, 'relations.csv'); const validTables = new Set<string>(NODE_TABLES as readonly string[]); const getNodeLabel = (nodeId: string): string => { if (nodeId.startsWith('comm_')) return 'Community'; @@ -99,34 +149,16 @@ export const loadGraphToKuzu = async ( return nodeId.split(':')[0]; }; - const relLines = csvData.relCSV.split('\n'); - const relHeader = relLines[0]; - const validRelLines = [relHeader]; - let skippedRels = 0; - for (let i = 1; i < relLines.length; i++) { - const line = relLines[i]; - if (!line.trim()) continue; - const match = line.match(/"([^"]*)","([^"]*)"/); - if (!match) { skippedRels++; continue; } - const fromLabel = getNodeLabel(match[1]); - const toLabel = getNodeLabel(match[2]); - if (!validTables.has(fromLabel) || !validTables.has(toLabel)) { - skippedRels++; - continue; - } - validRelLines.push(line); - } - await fs.writeFile(relCsvPath, validRelLines.join('\n'), 'utf-8'); - - // Bulk COPY all node CSVs + // Bulk COPY all node CSVs (sequential — LadybugDB allows only one write txn at a time) + const nodeFiles = [...csvResult.nodeFiles.entries()]; const totalSteps = nodeFiles.length + 1; // +1 for relationships let stepsDone = 0; - for (const { table, path: filePath, rows } of nodeFiles) { + for (const [table, { csvPath, rows }] of nodeFiles) { stepsDone++; log(`Loading nodes ${stepsDone}/${totalSteps}: ${table} (${rows.toLocaleString()} rows)`); - const normalizedPath = normalizeCopyPath(filePath); + const normalizedPath = normalizeCopyPath(csvPath); const copyQuery = getCopyQuery(table, normalizedPath); try { @@ -142,22 +174,40 @@ export const loadGraphToKuzu = async ( } } - // Bulk COPY relationships — split by FROM→TO label pair (KuzuDB requires it) - const insertedRels = validRelLines.length - 1; - const warnings: string[] = []; - if (insertedRels > 0) { - const relsByPair = new Map<string, string[]>(); - for (let i = 1; i < validRelLines.length; i++) { - const line = validRelLines[i]; + // Bulk COPY relationships — split by FROM→TO label pair (LadybugDB requires it) + // Stream-read the relation CSV line by line to avoid exceeding V8 max string length + let relHeader = ''; + const relsByPair = new Map<string, string[]>(); + let skippedRels = 0; + let totalValidRels = 0; + + await new Promise<void>((resolve, reject) => { + const rl = createInterface({ input: createReadStream(csvResult.relCsvPath, 'utf-8'), crlfDelay: Infinity }); + let isFirst = true; + rl.on('line', (line) => { + if (isFirst) { relHeader = line; isFirst = false; return; } + if (!line.trim()) return; const match = line.match(/"([^"]*)","([^"]*)"/); - if (!match) continue; + if (!match) { skippedRels++; return; } const fromLabel = getNodeLabel(match[1]); const toLabel = getNodeLabel(match[2]); + if (!validTables.has(fromLabel) || !validTables.has(toLabel)) { + skippedRels++; + return; + } const pairKey = `${fromLabel}|${toLabel}`; let list = relsByPair.get(pairKey); if (!list) { list = []; relsByPair.set(pairKey, list); } list.push(line); - } + totalValidRels++; + }); + rl.on('close', resolve); + rl.on('error', reject); + }); + + const insertedRels = totalValidRels; + const warnings: string[] = []; + if (insertedRels > 0) { log(`Loading edges: ${insertedRels.toLocaleString()} across ${relsByPair.size} types`); @@ -200,9 +250,9 @@ export const loadGraphToKuzu = async ( } // Cleanup all CSVs - try { await fs.unlink(relCsvPath); } catch {} - for (const { path: filePath } of nodeFiles) { - try { await fs.unlink(filePath); } catch {} + try { await fs.unlink(csvResult.relCsvPath); } catch {} + for (const [, { csvPath }] of csvResult.nodeFiles) { + try { await fs.unlink(csvPath); } catch {} } try { const remaining = await fs.readdir(csvDir); @@ -215,10 +265,10 @@ export const loadGraphToKuzu = async ( return { success: true, insertedRels, skippedRels, warnings }; }; -// KuzuDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes). +// LadybugDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes). // Source code content is full of backslashes which confuse the auto-detection. // We MUST explicitly set ESCAPE='"' to use RFC 4180 escaping, and disable auto_detect to prevent -// KuzuDB from overriding our settings based on sample rows. +// LadybugDB from overriding our settings based on sample rows. const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`; // Multi-language table names that were created with backticks in CODE_ELEMENT_BASE @@ -257,10 +307,11 @@ const fallbackRelationshipInserts = async ( const confidence = parseFloat(confidenceStr) || 1.0; const step = parseInt(stepStr) || 0; + const esc = (s: string) => s.replace(/'/g, "''").replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/\r/g, '\\r'); await conn.query(` - MATCH (a:${escapeLabel(fromLabel)} {id: '${fromId.replace(/'/g, "''")}' }), - (b:${escapeLabel(toLabel)} {id: '${toId.replace(/'/g, "''")}' }) - CREATE (a)-[:${REL_TABLE_NAME} {type: '${relType}', confidence: ${confidence}, reason: '${reason.replace(/'/g, "''")}', step: ${step}}]->(b) + MATCH (a:${escapeLabel(fromLabel)} {id: '${esc(fromId)}' }), + (b:${escapeLabel(toLabel)} {id: '${esc(toId)}' }) + CREATE (a)-[:${REL_TABLE_NAME} {type: '${esc(relType)}', confidence: ${confidence}, reason: '${esc(reason)}', step: ${step}}]->(b) `); } catch { // skip @@ -268,6 +319,9 @@ const fallbackRelationshipInserts = async ( } }; +/** Tables with isExported column (TypeScript/JS-native types) */ +const TABLES_WITH_EXPORTED = new Set<string>(['Function', 'Class', 'Interface', 'Method', 'CodeElement']); + const getCopyQuery = (table: NodeTableName, filePath: string): string => { const t = escapeTableName(table); if (table === 'File') { @@ -282,17 +336,24 @@ const getCopyQuery = (table: NodeTableName, filePath: string): string => { if (table === 'Process') { return `COPY ${t}(id, label, heuristicLabel, processType, stepCount, communities, entryPointId, terminalId) FROM "${filePath}" ${COPY_CSV_OPTS}`; } - // Code element tables (Function, Class, Interface, Method, CodeElement, and multi-language) - return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content) FROM "${filePath}" ${COPY_CSV_OPTS}`; + if (table === 'Method') { + return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description, parameterCount, returnType) FROM "${filePath}" ${COPY_CSV_OPTS}`; + } + // TypeScript/JS code element tables have isExported; multi-language tables do not + if (TABLES_WITH_EXPORTED.has(table)) { + return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description) FROM "${filePath}" ${COPY_CSV_OPTS}`; + } + // Multi-language tables (Struct, Impl, Trait, Macro, etc.) + return `COPY ${t}(id, name, filePath, startLine, endLine, content, description) FROM "${filePath}" ${COPY_CSV_OPTS}`; }; /** - * Insert a single node to KuzuDB + * Insert a single node to LadybugDB * @param label - Node type (File, Function, Class, etc.) * @param properties - Node properties - * @param dbPath - Path to KuzuDB database (optional if already initialized) + * @param dbPath - Path to LadybugDB database (optional if already initialized) */ -export const insertNodeToKuzu = async ( +export const insertNodeToLbug = async ( label: string, properties: Record<string, any>, dbPath?: string @@ -300,7 +361,7 @@ export const insertNodeToKuzu = async ( // Use provided dbPath or fall back to module-level db const targetDbPath = dbPath || (db ? undefined : null); if (!targetDbPath && !db) { - throw new Error('KuzuDB not initialized. Provide dbPath or call initKuzu first.'); + throw new Error('LadybugDB not initialized. Provide dbPath or call initLbug first.'); } try { @@ -308,25 +369,30 @@ export const insertNodeToKuzu = async ( if (v === null || v === undefined) return 'NULL'; if (typeof v === 'number') return String(v); // Escape backslashes first (for Windows paths), then single quotes - return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''")}'`; + return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/\n/g, '\\n').replace(/\r/g, '\\r')}'`; }; // Build INSERT query based on node type + const t = escapeTableName(label); let query: string; - + if (label === 'File') { query = `CREATE (n:File {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, content: ${escapeValue(properties.content || '')}})`; } else if (label === 'Folder') { query = `CREATE (n:Folder {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}})`; + } else if (TABLES_WITH_EXPORTED.has(label)) { + const descPart = properties.description ? `, description: ${escapeValue(properties.description)}` : ''; + query = `CREATE (n:${t} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, isExported: ${!!properties.isExported}, content: ${escapeValue(properties.content || '')}${descPart}})`; } else { - // Function, Class, Method, Interface, etc. - standard code element schema - query = `CREATE (n:${label} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, content: ${escapeValue(properties.content || '')}})`; + // Multi-language tables (Struct, Impl, Trait, Macro, etc.) — no isExported + const descPart = properties.description ? `, description: ${escapeValue(properties.description)}` : ''; + query = `CREATE (n:${t} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, content: ${escapeValue(properties.content || '')}${descPart}})`; } - + // Use per-query connection if dbPath provided (avoids lock conflicts) if (targetDbPath) { - const tempDb = new kuzu.Database(targetDbPath); - const tempConn = new kuzu.Connection(tempDb); + const tempDb = new lbug.Database(targetDbPath); + const tempConn = new lbug.Connection(tempDb); try { await tempConn.query(query); return true; @@ -339,7 +405,7 @@ export const insertNodeToKuzu = async ( await conn.query(query); return true; } - + return false; } catch (e: any) { // Node may already exist or other error @@ -349,45 +415,50 @@ export const insertNodeToKuzu = async ( }; /** - * Batch insert multiple nodes to KuzuDB using a single connection + * Batch insert multiple nodes to LadybugDB using a single connection * @param nodes - Array of {label, properties} to insert - * @param dbPath - Path to KuzuDB database + * @param dbPath - Path to LadybugDB database * @returns Object with success count and error count */ -export const batchInsertNodesToKuzu = async ( +export const batchInsertNodesToLbug = async ( nodes: Array<{ label: string; properties: Record<string, any> }>, dbPath: string ): Promise<{ inserted: number; failed: number }> => { if (nodes.length === 0) return { inserted: 0, failed: 0 }; - + const escapeValue = (v: any): string => { if (v === null || v === undefined) return 'NULL'; if (typeof v === 'number') return String(v); - // Escape backslashes first (for Windows paths), then single quotes - return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''")}'`; + // Escape backslashes first (for Windows paths), then single quotes, then newlines + return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/\n/g, '\\n').replace(/\r/g, '\\r')}'`; }; - + // Open a single connection for all inserts - const tempDb = new kuzu.Database(dbPath); - const tempConn = new kuzu.Connection(tempDb); - + const tempDb = new lbug.Database(dbPath); + const tempConn = new lbug.Connection(tempDb); + let inserted = 0; let failed = 0; - + try { for (const { label, properties } of nodes) { try { let query: string; - + // Use MERGE instead of CREATE for upsert behavior (handles duplicates gracefully) + const t = escapeTableName(label); if (label === 'File') { query = `MERGE (n:File {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.content = ${escapeValue(properties.content || '')}`; } else if (label === 'Folder') { query = `MERGE (n:Folder {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}`; + } else if (TABLES_WITH_EXPORTED.has(label)) { + const descPart = properties.description ? `, n.description = ${escapeValue(properties.description)}` : ''; + query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.isExported = ${!!properties.isExported}, n.content = ${escapeValue(properties.content || '')}${descPart}`; } else { - query = `MERGE (n:${label} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.content = ${escapeValue(properties.content || '')}`; + const descPart = properties.description ? `, n.description = ${escapeValue(properties.description)}` : ''; + query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.content = ${escapeValue(properties.content || '')}${descPart}`; } - + await tempConn.query(query); inserted++; } catch (e: any) { @@ -399,17 +470,17 @@ export const batchInsertNodesToKuzu = async ( try { await tempConn.close(); } catch {} try { await tempDb.close(); } catch {} } - + return { inserted, failed }; }; export const executeQuery = async (cypher: string): Promise<any[]> => { if (!conn) { - throw new Error('KuzuDB not initialized. Call initKuzu first.'); + throw new Error('LadybugDB not initialized. Call initLbug first.'); } const queryResult = await conn.query(cypher); - // kuzu v0.11 uses getAll() instead of hasNext()/getNext() + // LadybugDB uses getAll() instead of hasNext()/getNext() // Query returns QueryResult for single queries, QueryResult[] for multi-statement const result = Array.isArray(queryResult) ? queryResult[0] : queryResult; const rows = await result.getAll(); @@ -421,7 +492,7 @@ export const executeWithReusedStatement = async ( paramsList: Array<Record<string, any>> ): Promise<void> => { if (!conn) { - throw new Error('KuzuDB not initialized. Call initKuzu first.'); + throw new Error('LadybugDB not initialized. Call initLbug first.'); } if (paramsList.length === 0) return; @@ -441,17 +512,17 @@ export const executeWithReusedStatement = async ( // Log the error and continue with next batch console.warn('Batch execution error:', e); } - // Note: kuzu 0.8.2 PreparedStatement doesn't require explicit close() + // Note: LadybugDB PreparedStatement doesn't require explicit close() } }; -export const getKuzuStats = async (): Promise<{ nodes: number; edges: number }> => { +export const getLbugStats = async (): Promise<{ nodes: number; edges: number }> => { if (!conn) return { nodes: 0, edges: 0 }; let totalNodes = 0; for (const tableName of NODE_TABLES) { try { - const queryResult = await conn.query(`MATCH (n:${tableName}) RETURN count(n) AS cnt`); + const queryResult = await conn.query(`MATCH (n:${escapeTableName(tableName)}) RETURN count(n) AS cnt`); const nodeResult = Array.isArray(queryResult) ? queryResult[0] : queryResult; const nodeRows = await nodeResult.getAll(); if (nodeRows.length > 0) { @@ -478,7 +549,7 @@ export const getKuzuStats = async (): Promise<{ nodes: number; edges: number }> }; /** - * Load cached embeddings from KuzuDB before a rebuild. + * Load cached embeddings from LadybugDB before a rebuild. * Returns all embedding vectors so they can be re-inserted after the graph is reloaded, * avoiding expensive re-embedding of unchanged nodes. */ @@ -512,7 +583,7 @@ export const loadCachedEmbeddings = async (): Promise<{ return { embeddingNodeIds, embeddings }; }; -export const closeKuzu = async (): Promise<void> => { +export const closeLbug = async (): Promise<void> => { if (conn) { try { await conn.close(); @@ -525,55 +596,59 @@ export const closeKuzu = async (): Promise<void> => { } catch {} db = null; } + currentDbPath = null; + ftsLoaded = false; }; -export const isKuzuReady = (): boolean => conn !== null && db !== null; +export const isLbugReady = (): boolean => conn !== null && db !== null; + /** - * Delete all nodes (and their relationships) for a specific file from KuzuDB + * Delete all nodes (and their relationships) for a specific file from LadybugDB * @param filePath - The file path to delete nodes for - * @param dbPath - Optional path to KuzuDB for per-query connection + * @param dbPath - Optional path to LadybugDB for per-query connection * @returns Object with counts of deleted nodes */ export const deleteNodesForFile = async (filePath: string, dbPath?: string): Promise<{ deletedNodes: number }> => { const usePerQuery = !!dbPath; - + // Set up connection (either use existing or create per-query) - let tempDb: kuzu.Database | null = null; - let tempConn: kuzu.Connection | null = null; - let targetConn: kuzu.Connection | null = conn; - + let tempDb: lbug.Database | null = null; + let tempConn: lbug.Connection | null = null; + let targetConn: lbug.Connection | null = conn; + if (usePerQuery) { - tempDb = new kuzu.Database(dbPath); - tempConn = new kuzu.Connection(tempDb); + tempDb = new lbug.Database(dbPath); + tempConn = new lbug.Connection(tempDb); targetConn = tempConn; } else if (!conn) { - throw new Error('KuzuDB not initialized. Provide dbPath or call initKuzu first.'); + throw new Error('LadybugDB not initialized. Provide dbPath or call initLbug first.'); } - + try { let deletedNodes = 0; const escapedPath = filePath.replace(/'/g, "''"); - + // Delete nodes from each table that has filePath // DETACH DELETE removes the node and all its relationships for (const tableName of NODE_TABLES) { // Skip tables that don't have filePath (Community, Process) if (tableName === 'Community' || tableName === 'Process') continue; - + try { // First count how many we'll delete + const tn = escapeTableName(tableName); const countResult = await targetConn!.query( - `MATCH (n:${tableName}) WHERE n.filePath = '${escapedPath}' RETURN count(n) AS cnt` + `MATCH (n:${tn}) WHERE n.filePath = '${escapedPath}' RETURN count(n) AS cnt` ); const result = Array.isArray(countResult) ? countResult[0] : countResult; const rows = await result.getAll(); const count = Number(rows[0]?.cnt ?? rows[0]?.[0] ?? 0); - + if (count > 0) { // Delete nodes (and implicitly their relationships via DETACH) await targetConn!.query( - `MATCH (n:${tableName}) WHERE n.filePath = '${escapedPath}' DETACH DELETE n` + `MATCH (n:${tn}) WHERE n.filePath = '${escapedPath}' DETACH DELETE n` ); deletedNodes += count; } @@ -581,7 +656,7 @@ export const deleteNodesForFile = async (filePath: string, dbPath?: string): Pro // Some tables may not support this query, skip } } - + // Also delete any embeddings for nodes in this file try { await targetConn!.query( @@ -590,7 +665,7 @@ export const deleteNodesForFile = async (filePath: string, dbPath?: string): Pro } catch { // Embedding table may not exist or nodeId format may differ } - + return { deletedNodes }; } finally { // Close per-query connection if used @@ -610,17 +685,25 @@ export const getEmbeddingTableName = (): string => EMBEDDING_TABLE_NAME; // ============================================================================ /** - * Load the FTS extension (required before using FTS functions) + * Load the FTS extension (required before using FTS functions). + * Safe to call multiple times — tracks loaded state via module-level ftsLoaded. */ export const loadFTSExtension = async (): Promise<void> => { + if (ftsLoaded) return; if (!conn) { - throw new Error('KuzuDB not initialized. Call initKuzu first.'); + throw new Error('LadybugDB not initialized. Call initLbug first.'); } try { await conn.query('INSTALL fts'); await conn.query('LOAD EXTENSION fts'); - } catch { - // Extension may already be loaded + ftsLoaded = true; + } catch (err: any) { + const msg = err?.message || ''; + if (msg.includes('already loaded') || msg.includes('already installed') || msg.includes('already exists')) { + ftsLoaded = true; + } else { + console.error('GitNexus: FTS extension load failed:', msg); + } } }; @@ -638,18 +721,17 @@ export const createFTSIndex = async ( stemmer: string = 'porter' ): Promise<void> => { if (!conn) { - throw new Error('KuzuDB not initialized. Call initKuzu first.'); + throw new Error('LadybugDB not initialized. Call initLbug first.'); } - + await loadFTSExtension(); - + const propList = properties.map(p => `'${p}'`).join(', '); const query = `CALL CREATE_FTS_INDEX('${tableName}', '${indexName}', [${propList}], stemmer := '${stemmer}')`; - + try { await conn.query(query); } catch (e: any) { - // Index may already exist if (!e.message?.includes('already exists')) { throw e; } @@ -673,24 +755,24 @@ export const queryFTS = async ( conjunctive: boolean = false ): Promise<Array<{ nodeId: string; name: string; filePath: string; score: number; [key: string]: any }>> => { if (!conn) { - throw new Error('KuzuDB not initialized. Call initKuzu first.'); + throw new Error('LadybugDB not initialized. Call initLbug first.'); } - - // Escape single quotes in query - const escapedQuery = query.replace(/'/g, "''"); - + + // Escape backslashes and single quotes to prevent Cypher injection + const escapedQuery = query.replace(/\\/g, '\\\\').replace(/'/g, "''"); + const cypher = ` CALL QUERY_FTS_INDEX('${tableName}', '${indexName}', '${escapedQuery}', conjunctive := ${conjunctive}) RETURN node, score ORDER BY score DESC LIMIT ${limit} `; - + try { const queryResult = await conn.query(cypher); const result = Array.isArray(queryResult) ? queryResult[0] : queryResult; const rows = await result.getAll(); - + return rows.map((row: any) => { const node = row.node || row[0] || {}; const score = row.score ?? row[1] ?? 0; @@ -716,9 +798,9 @@ export const queryFTS = async ( */ export const dropFTSIndex = async (tableName: string, indexName: string): Promise<void> => { if (!conn) { - throw new Error('KuzuDB not initialized. Call initKuzu first.'); + throw new Error('LadybugDB not initialized. Call initLbug first.'); } - + try { await conn.query(`CALL DROP_FTS_INDEX('${tableName}', '${indexName}')`); } catch { diff --git a/gitnexus/src/core/kuzu/schema.ts b/gitnexus/src/core/lbug/schema.ts similarity index 88% rename from gitnexus/src/core/kuzu/schema.ts rename to gitnexus/src/core/lbug/schema.ts index c0f3b394a0..ef1fbad507 100644 --- a/gitnexus/src/core/kuzu/schema.ts +++ b/gitnexus/src/core/lbug/schema.ts @@ -1,5 +1,5 @@ /** - * KuzuDB Schema Definitions + * LadybugDB Schema Definitions * * Hybrid Schema: * - Separate node tables for each code element type (File, Function, Class, etc.) @@ -26,7 +26,7 @@ export type NodeTableName = typeof NODE_TABLES[number]; export const REL_TABLE_NAME = 'CodeRelation'; // Valid relation types -export const REL_TYPES = ['CONTAINS', 'DEFINES', 'IMPORTS', 'CALLS', 'EXTENDS', 'IMPLEMENTS', 'MEMBER_OF', 'STEP_IN_PROCESS'] as const; +export const REL_TYPES = ['CONTAINS', 'DEFINES', 'IMPORTS', 'CALLS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'ACCESSES', 'OVERRIDES', 'MEMBER_OF', 'STEP_IN_PROCESS'] as const; export type RelType = typeof REL_TYPES[number]; // ============================================================================ @@ -64,6 +64,7 @@ CREATE NODE TABLE Function ( endLine INT64, isExported BOOLEAN, content STRING, + description STRING, PRIMARY KEY (id) )`; @@ -76,6 +77,7 @@ CREATE NODE TABLE Class ( endLine INT64, isExported BOOLEAN, content STRING, + description STRING, PRIMARY KEY (id) )`; @@ -88,6 +90,7 @@ CREATE NODE TABLE Interface ( endLine INT64, isExported BOOLEAN, content STRING, + description STRING, PRIMARY KEY (id) )`; @@ -100,6 +103,9 @@ CREATE NODE TABLE Method ( endLine INT64, isExported BOOLEAN, content STRING, + description STRING, + parameterCount INT32, + returnType STRING, PRIMARY KEY (id) )`; @@ -112,6 +118,7 @@ CREATE NODE TABLE CodeElement ( endLine INT64, isExported BOOLEAN, content STRING, + description STRING, PRIMARY KEY (id) )`; @@ -154,6 +161,7 @@ CREATE NODE TABLE Process ( // ============================================================================ // Generic code element with startLine/endLine for C, C++, Rust, Go, Java, C# +// description: optional metadata (e.g. Eloquent $fillable fields, relationship targets) const CODE_ELEMENT_BASE = (name: string) => ` CREATE NODE TABLE \`${name}\` ( id STRING, @@ -162,6 +170,7 @@ CREATE NODE TABLE \`${name}\` ( startLine INT64, endLine INT64, content STRING, + description STRING, PRIMARY KEY (id) )`; @@ -232,6 +241,10 @@ CREATE REL TABLE ${REL_TABLE_NAME} ( FROM Function TO \`Impl\`, FROM Function TO Interface, FROM Function TO \`Constructor\`, + FROM Function TO \`Const\`, + FROM Function TO \`Typedef\`, + FROM Function TO \`Union\`, + FROM Function TO \`Property\`, FROM Class TO Method, FROM Class TO Function, FROM Class TO Class, @@ -243,6 +256,13 @@ CREATE REL TABLE ${REL_TABLE_NAME} ( FROM Class TO \`Enum\`, FROM Class TO \`Annotation\`, FROM Class TO \`Constructor\`, + FROM Class TO \`Trait\`, + FROM Class TO \`Macro\`, + FROM Class TO \`Impl\`, + FROM Class TO \`Union\`, + FROM Class TO \`Namespace\`, + FROM Class TO \`Typedef\`, + FROM Class TO \`Property\`, FROM Method TO Function, FROM Method TO Method, FROM Method TO Class, @@ -257,6 +277,7 @@ CREATE REL TABLE ${REL_TABLE_NAME} ( FROM Method TO \`Impl\`, FROM Method TO Interface, FROM Method TO \`Constructor\`, + FROM Method TO \`Property\`, FROM \`Template\` TO \`Template\`, FROM \`Template\` TO Function, FROM \`Template\` TO Method, @@ -277,11 +298,21 @@ CREATE REL TABLE ${REL_TABLE_NAME} ( FROM Interface TO \`TypeAlias\`, FROM Interface TO \`Struct\`, FROM Interface TO \`Constructor\`, + FROM Interface TO \`Property\`, FROM \`Struct\` TO Community, FROM \`Struct\` TO \`Trait\`, + FROM \`Struct\` TO \`Struct\`, + FROM \`Struct\` TO Class, + FROM \`Struct\` TO \`Enum\`, FROM \`Struct\` TO Function, FROM \`Struct\` TO Method, + FROM \`Struct\` TO Interface, + FROM \`Struct\` TO \`Constructor\`, + FROM \`Struct\` TO \`Property\`, + FROM \`Enum\` TO \`Enum\`, FROM \`Enum\` TO Community, + FROM \`Enum\` TO Class, + FROM \`Enum\` TO Interface, FROM \`Macro\` TO Community, FROM \`Macro\` TO Function, FROM \`Macro\` TO Method, @@ -290,13 +321,27 @@ CREATE REL TABLE ${REL_TABLE_NAME} ( FROM \`Typedef\` TO Community, FROM \`Union\` TO Community, FROM \`Namespace\` TO Community, + FROM \`Namespace\` TO \`Struct\`, + FROM \`Trait\` TO Method, + FROM \`Trait\` TO \`Constructor\`, + FROM \`Trait\` TO \`Property\`, FROM \`Trait\` TO Community, + FROM \`Impl\` TO Method, + FROM \`Impl\` TO \`Constructor\`, + FROM \`Impl\` TO \`Property\`, FROM \`Impl\` TO Community, FROM \`Impl\` TO \`Trait\`, + FROM \`Impl\` TO \`Struct\`, + FROM \`Impl\` TO \`Impl\`, FROM \`TypeAlias\` TO Community, + FROM \`TypeAlias\` TO \`Trait\`, + FROM \`TypeAlias\` TO Class, FROM \`Const\` TO Community, FROM \`Static\` TO Community, FROM \`Property\` TO Community, + FROM \`Record\` TO Method, + FROM \`Record\` TO \`Constructor\`, + FROM \`Record\` TO \`Property\`, FROM \`Record\` TO Community, FROM \`Delegate\` TO Community, FROM \`Annotation\` TO Community, @@ -315,6 +360,8 @@ CREATE REL TABLE ${REL_TABLE_NAME} ( FROM \`Constructor\` TO \`Impl\`, FROM \`Constructor\` TO \`Namespace\`, FROM \`Constructor\` TO \`Module\`, + FROM \`Constructor\` TO \`Property\`, + FROM \`Constructor\` TO \`Typedef\`, FROM \`Template\` TO Community, FROM \`Module\` TO Community, FROM Function TO Process, diff --git a/gitnexus/src/core/search/bm25-index.ts b/gitnexus/src/core/search/bm25-index.ts index d20ef1b801..b118a788d7 100644 --- a/gitnexus/src/core/search/bm25-index.ts +++ b/gitnexus/src/core/search/bm25-index.ts @@ -1,11 +1,11 @@ /** - * Full-Text Search via KuzuDB FTS - * - * Uses KuzuDB's built-in full-text search indexes for keyword-based search. + * Full-Text Search via LadybugDB FTS + * + * Uses LadybugDB's built-in full-text search indexes for keyword-based search. * Always reads from the database (no cached state to drift). */ -import { queryFTS } from '../kuzu/kuzu-adapter.js'; +import { queryFTS } from '../lbug/lbug-adapter.js'; export interface BM25SearchResult { filePath: string; @@ -15,7 +15,7 @@ export interface BM25SearchResult { /** * Execute a single FTS query via a custom executor (for MCP connection pool). - * Returns the same shape as core queryFTS. + * Returns the same shape as core queryFTS (from LadybugDB adapter). */ async function queryFTSViaExecutor( executor: (cypher: string) => Promise<any[]>, @@ -24,7 +24,8 @@ async function queryFTSViaExecutor( query: string, limit: number, ): Promise<Array<{ filePath: string; score: number }>> { - const escapedQuery = query.replace(/'/g, "''"); + // Escape single quotes and backslashes to prevent Cypher injection + const escapedQuery = query.replace(/\\/g, '\\\\').replace(/'/g, "''"); const cypher = ` CALL QUERY_FTS_INDEX('${tableName}', '${indexName}', '${escapedQuery}', conjunctive := false) RETURN node, score @@ -47,24 +48,24 @@ async function queryFTSViaExecutor( } /** - * Search using KuzuDB's built-in FTS (always fresh, reads from disk) - * + * Search using LadybugDB's built-in FTS (always fresh, reads from disk) + * * Queries multiple node tables (File, Function, Class, Method) in parallel * and merges results by filePath, summing scores for the same file. - * + * * @param query - Search query string * @param limit - Maximum results * @param repoId - If provided, queries will be routed via the MCP connection pool * @returns Ranked search results from FTS indexes */ -export const searchFTSFromKuzu = async (query: string, limit: number = 20, repoId?: string): Promise<BM25SearchResult[]> => { +export const searchFTSFromLbug = async (query: string, limit: number = 20, repoId?: string): Promise<BM25SearchResult[]> => { let fileResults: any[], functionResults: any[], classResults: any[], methodResults: any[], interfaceResults: any[]; if (repoId) { // Use MCP connection pool via dynamic import - // IMPORTANT: KuzuDB uses a single connection per repo — queries must be sequential - // to avoid deadlocking. Do NOT use Promise.all here. - const { executeQuery } = await import('../../mcp/core/kuzu-adapter.js'); + // IMPORTANT: FTS queries run sequentially to avoid connection contention. + // The MCP pool supports multiple connections, but FTS is best run serially. + const { executeQuery } = await import('../../mcp/core/lbug-adapter.js'); const executor = (cypher: string) => executeQuery(repoId, cypher); fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit); functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit); @@ -72,7 +73,7 @@ export const searchFTSFromKuzu = async (query: string, limit: number = 20, repoI methodResults = await queryFTSViaExecutor(executor, 'Method', 'method_fts', query, limit); interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit); } else { - // Use core kuzu adapter (CLI / pipeline context) — also sequential for safety + // Use core lbug adapter (CLI / pipeline context) — also sequential for safety fileResults = await queryFTS('File', 'file_fts', query, limit, false).catch(() => []); functionResults = await queryFTS('Function', 'function_fts', query, limit, false).catch(() => []); classResults = await queryFTS('Class', 'class_fts', query, limit, false).catch(() => []); diff --git a/gitnexus/src/core/search/hybrid-search.ts b/gitnexus/src/core/search/hybrid-search.ts index 16d3bc42de..649c67160e 100644 --- a/gitnexus/src/core/search/hybrid-search.ts +++ b/gitnexus/src/core/search/hybrid-search.ts @@ -8,7 +8,7 @@ * production search systems. */ -import { searchFTSFromKuzu, type BM25SearchResult } from './bm25-index.js'; +import { searchFTSFromLbug, type BM25SearchResult } from './bm25-index.js'; import type { SemanticSearchResult } from '../embeddings/types.js'; /** @@ -114,11 +114,11 @@ export const mergeWithRRF = ( /** * Check if hybrid search is available - * KuzuDB FTS is always available once the database is initialized. + * LadybugDB FTS is always available once the database is initialized. * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready. */ export const isHybridSearchReady = (): boolean => { - return true; // FTS is always available via KuzuDB when DB is open + return true; // FTS is always available via LadybugDB when DB is open }; /** @@ -146,7 +146,7 @@ export const formatHybridResults = (results: HybridSearchResult[]): string => { /** * Execute BM25 + semantic search and merge with RRF. - * Uses KuzuDB FTS for always-fresh BM25 results (no cached data). + * Uses LadybugDB FTS for always-fresh BM25 results (no cached data). * The semanticSearch function is injected to keep this module environment-agnostic. */ export const hybridSearch = async ( @@ -155,8 +155,8 @@ export const hybridSearch = async ( executeQuery: (cypher: string) => Promise<any[]>, semanticSearch: (executeQuery: (cypher: string) => Promise<any[]>, query: string, k?: number) => Promise<SemanticSearchResult[]> ): Promise<HybridSearchResult[]> => { - // Use KuzuDB FTS for always-fresh BM25 results - const bm25Results = await searchFTSFromKuzu(query, limit); + // Use LadybugDB FTS for always-fresh BM25 results + const bm25Results = await searchFTSFromLbug(query, limit); const semanticResults = await semanticSearch(executeQuery, query, limit); return mergeWithRRF(bm25Results, semanticResults, limit); }; diff --git a/gitnexus/src/core/tree-sitter/parser-loader.ts b/gitnexus/src/core/tree-sitter/parser-loader.ts index cdca3003da..f7740ab6c1 100644 --- a/gitnexus/src/core/tree-sitter/parser-loader.ts +++ b/gitnexus/src/core/tree-sitter/parser-loader.ts @@ -8,8 +8,20 @@ import CPP from 'tree-sitter-cpp'; import CSharp from 'tree-sitter-c-sharp'; import Go from 'tree-sitter-go'; import Rust from 'tree-sitter-rust'; +import PHP from 'tree-sitter-php'; +import Ruby from 'tree-sitter-ruby'; +import { createRequire } from 'node:module'; import { SupportedLanguages } from '../../config/supported-languages.js'; +// tree-sitter-swift is an optionalDependency — may not be installed +const _require = createRequire(import.meta.url); +let Swift: any = null; +try { Swift = _require('tree-sitter-swift'); } catch {} + +// tree-sitter-kotlin is an optionalDependency — may not be installed +let Kotlin: any = null; +try { Kotlin = _require('tree-sitter-kotlin'); } catch {} + let parser: Parser | null = null; const languageMap: Record<string, any> = { @@ -23,8 +35,15 @@ const languageMap: Record<string, any> = { [SupportedLanguages.CSharp]: CSharp, [SupportedLanguages.Go]: Go, [SupportedLanguages.Rust]: Rust, + ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}), + [SupportedLanguages.PHP]: PHP.php_only, + [SupportedLanguages.Ruby]: Ruby, + ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}), }; +export const isLanguageAvailable = (language: SupportedLanguages): boolean => + language in languageMap; + export const loadParser = async (): Promise<Parser> => { if (parser) return parser; parser = new Parser(); diff --git a/gitnexus/src/core/wiki/generator.ts b/gitnexus/src/core/wiki/generator.ts index 29a16a5419..67fb575b97 100644 --- a/gitnexus/src/core/wiki/generator.ts +++ b/gitnexus/src/core/wiki/generator.ts @@ -12,7 +12,7 @@ import fs from 'fs/promises'; import path from 'path'; -import { execSync } from 'child_process'; +import { execSync, execFileSync } from 'child_process'; import { initWikiDb, @@ -93,7 +93,7 @@ export class WikiGenerator { private repoPath: string; private storagePath: string; private wikiDir: string; - private kuzuPath: string; + private lbugPath: string; private llmConfig: LLMConfig; private maxTokensPerModule: number; private concurrency: number; @@ -104,7 +104,7 @@ export class WikiGenerator { constructor( repoPath: string, storagePath: string, - kuzuPath: string, + lbugPath: string, llmConfig: LLMConfig, options: WikiOptions = {}, onProgress?: ProgressCallback, @@ -112,7 +112,7 @@ export class WikiGenerator { this.repoPath = repoPath; this.storagePath = storagePath; this.wikiDir = path.join(storagePath, WIKI_DIR); - this.kuzuPath = kuzuPath; + this.lbugPath = lbugPath; this.options = options; this.llmConfig = llmConfig; this.maxTokensPerModule = options.maxTokensPerModule ?? DEFAULT_MAX_TOKENS_PER_MODULE; @@ -171,7 +171,7 @@ export class WikiGenerator { // Init graph this.onProgress('init', 2, 'Connecting to knowledge graph...'); - await initWikiDb(this.kuzuPath); + await initWikiDb(this.lbugPath); let result: { pagesGenerated: number; mode: 'full' | 'incremental' | 'up-to-date'; failedModules: string[] }; try { @@ -712,8 +712,8 @@ export class WikiGenerator { private getChangedFiles(fromCommit: string, toCommit: string): string[] { try { - const output = execSync( - `git diff ${fromCommit}..${toCommit} --name-only`, + const output = execFileSync( + 'git', ['diff', `${fromCommit}..${toCommit}`, '--name-only'], { cwd: this.repoPath }, ).toString().trim(); return output ? output.split('\n').filter(Boolean) : []; diff --git a/gitnexus/src/core/wiki/graph-queries.ts b/gitnexus/src/core/wiki/graph-queries.ts index f32161e167..aa9d1e3615 100644 --- a/gitnexus/src/core/wiki/graph-queries.ts +++ b/gitnexus/src/core/wiki/graph-queries.ts @@ -1,11 +1,11 @@ /** * Graph Queries for Wiki Generation - * + * * Encapsulated Cypher queries against the GitNexus knowledge graph. - * Uses the MCP-style pooled kuzu-adapter for connection management. + * Uses the MCP-style pooled lbug-adapter for connection management. */ -import { initKuzu, executeQuery, closeKuzu } from '../../mcp/core/kuzu-adapter.js'; +import { initLbug, executeQuery, closeLbug } from '../../mcp/core/lbug-adapter.js'; const REPO_ID = '__wiki__'; @@ -35,17 +35,17 @@ export interface ProcessInfo { } /** - * Initialize the KuzuDB connection for wiki generation. + * Initialize the LadybugDB connection for wiki generation. */ -export async function initWikiDb(kuzuPath: string): Promise<void> { - await initKuzu(REPO_ID, kuzuPath); +export async function initWikiDb(lbugPath: string): Promise<void> { + await initLbug(REPO_ID, lbugPath); } /** - * Close the KuzuDB connection. + * Close the LadybugDB connection. */ export async function closeWikiDb(): Promise<void> { - await closeKuzu(REPO_ID); + await closeLbug(REPO_ID); } /** diff --git a/gitnexus/src/mcp/compatible-stdio-transport.ts b/gitnexus/src/mcp/compatible-stdio-transport.ts new file mode 100644 index 0000000000..8912c58184 --- /dev/null +++ b/gitnexus/src/mcp/compatible-stdio-transport.ts @@ -0,0 +1,240 @@ +import process from 'node:process'; +import type { Transport, TransportSendOptions } from '@modelcontextprotocol/sdk/shared/transport.js'; +import { JSONRPCMessageSchema, type JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js'; + +export type StdioFraming = 'content-length' | 'newline'; + +function deserializeMessage(raw: string): JSONRPCMessage { + return JSONRPCMessageSchema.parse(JSON.parse(raw)); +} + +function serializeNewlineMessage(message: JSONRPCMessage): string { + return `${JSON.stringify(message)}\n`; +} + +function serializeContentLengthMessage(message: JSONRPCMessage): string { + const body = JSON.stringify(message); + return `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`; +} + +function findHeaderEnd(buffer: Buffer): { index: number; separatorLength: number } | null { + const crlfEnd = buffer.indexOf('\r\n\r\n'); + if (crlfEnd !== -1) { + return { index: crlfEnd, separatorLength: 4 }; + } + + const lfEnd = buffer.indexOf('\n\n'); + if (lfEnd !== -1) { + return { index: lfEnd, separatorLength: 2 }; + } + + return null; +} + +function looksLikeContentLength(buffer: Buffer): boolean { + if (buffer.length < 14) { + return false; + } + const probe = buffer.toString('utf8', 0, Math.min(buffer.length, 32)); + return /^content-length\s*:/i.test(probe); +} + +const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10 MB — generous for JSON-RPC + +export class CompatibleStdioServerTransport implements Transport { + private _readBuffer: Buffer | undefined; + private _started = false; + private _framing: StdioFraming | null = null; + + onmessage?: (message: JSONRPCMessage) => void; + onerror?: (error: Error) => void; + onclose?: () => void; + + constructor( + private readonly _stdin: NodeJS.ReadableStream = process.stdin, + private readonly _stdout: NodeJS.WritableStream = process.stdout, + ) {} + + private readonly _ondata = (chunk: Buffer) => { + this._readBuffer = this._readBuffer ? Buffer.concat([this._readBuffer, chunk]) : chunk; + if (this._readBuffer.length > MAX_BUFFER_SIZE) { + this.onerror?.(new Error(`Read buffer exceeded maximum size (${MAX_BUFFER_SIZE} bytes)`)); + this.discardBufferedInput(); + return; + } + this.processReadBuffer(); + }; + + private readonly _onerror = (error: Error) => { + this.onerror?.(error); + }; + + async start() { + if (this._started) { + throw new Error('CompatibleStdioServerTransport already started!'); + } + + this._started = true; + this._stdin.on('data', this._ondata); + this._stdin.on('error', this._onerror); + } + + private detectFraming(): StdioFraming | null { + if (!this._readBuffer || this._readBuffer.length === 0) { + return null; + } + + const firstByte = this._readBuffer[0]; + if (firstByte === 0x7b || firstByte === 0x5b) { + return 'newline'; + } + + if (looksLikeContentLength(this._readBuffer)) { + return 'content-length'; + } + + return null; + } + + private discardBufferedInput() { + this._readBuffer = undefined; + this._framing = null; + } + + private readContentLengthMessage(): JSONRPCMessage | null { + if (!this._readBuffer) { + return null; + } + + const header = findHeaderEnd(this._readBuffer); + if (header === null) { + return null; + } + + const headerText = this._readBuffer + .toString('utf8', 0, header.index) + .replace(/\r\n/g, '\n') + .replace(/\r/g, '\n'); + const match = headerText.match(/(?:^|\n)content-length\s*:\s*(\d+)/i); + if (!match) { + this.discardBufferedInput(); + throw new Error('Missing Content-Length header from MCP client'); + } + + const contentLength = Number.parseInt(match[1], 10); + if (!Number.isFinite(contentLength) || contentLength < 0) { + this.discardBufferedInput(); + throw new Error('Invalid Content-Length header from MCP client'); + } + if (contentLength > MAX_BUFFER_SIZE) { + this.discardBufferedInput(); + throw new Error(`Content-Length ${contentLength} exceeds maximum allowed size (${MAX_BUFFER_SIZE} bytes)`); + } + const bodyStart = header.index + header.separatorLength; + const bodyEnd = bodyStart + contentLength; + if (this._readBuffer.length < bodyEnd) { + return null; + } + + const body = this._readBuffer.toString('utf8', bodyStart, bodyEnd); + this._readBuffer = this._readBuffer.subarray(bodyEnd); + return deserializeMessage(body); + } + + private readNewlineMessage(): JSONRPCMessage | null { + if (!this._readBuffer) { + return null; + } + + while (true) { + const newlineIndex = this._readBuffer.indexOf('\n'); + if (newlineIndex === -1) { + return null; + } + + const line = this._readBuffer.toString('utf8', 0, newlineIndex).replace(/\r$/, ''); + this._readBuffer = this._readBuffer.subarray(newlineIndex + 1); + if (line.trim().length === 0) { + continue; + } + + return deserializeMessage(line); + } + } + + private readMessage(): JSONRPCMessage | null { + if (!this._readBuffer || this._readBuffer.length === 0) { + return null; + } + + if (this._framing === null) { + this._framing = this.detectFraming(); + if (this._framing === null) { + return null; + } + } + + return this._framing === 'content-length' + ? this.readContentLengthMessage() + : this.readNewlineMessage(); + } + + private processReadBuffer() { + while (true) { + try { + const message = this.readMessage(); + if (message === null) { + break; + } + this.onmessage?.(message); + } catch (error) { + this.onerror?.(error as Error); + break; + } + } + } + + async close() { + this._stdin.off('data', this._ondata); + this._stdin.off('error', this._onerror); + + const remainingDataListeners = this._stdin.listenerCount('data'); + if (remainingDataListeners === 0) { + this._stdin.pause(); + } + + this._started = false; + this._readBuffer = undefined; + this.onclose?.(); + } + + send(message: JSONRPCMessage, _options?: TransportSendOptions) { + return new Promise<void>((resolve, reject) => { + if (!this._started) { + reject(new Error('Transport is closed')); + return; + } + + const payload = this._framing === 'newline' + ? serializeNewlineMessage(message) + : serializeContentLengthMessage(message); + + const onError = (error: Error) => { + this._stdout.removeListener('error', onError); + reject(error); + }; + + this._stdout.on('error', onError); + + if (this._stdout.write(payload)) { + this._stdout.removeListener('error', onError); + resolve(); + } else { + this._stdout.once('drain', () => { + this._stdout.removeListener('error', onError); + resolve(); + }); + } + }); + } +} diff --git a/gitnexus/src/mcp/core/kuzu-adapter.ts b/gitnexus/src/mcp/core/kuzu-adapter.ts deleted file mode 100644 index ba0237164e..0000000000 --- a/gitnexus/src/mcp/core/kuzu-adapter.ts +++ /dev/null @@ -1,262 +0,0 @@ -/** - * KuzuDB Adapter (Connection Pool) - * - * Manages a pool of KuzuDB databases keyed by repoId, each with - * multiple Connection objects for safe concurrent query execution. - * - * KuzuDB Connections are NOT thread-safe — a single Connection - * segfaults if concurrent .query() calls hit it simultaneously. - * This adapter provides a checkout/return connection pool so each - * concurrent query gets its own Connection from the same Database. - * - * @see https://docs.kuzudb.com/concurrency — multiple Connections - * from the same Database is the officially supported concurrency pattern. - */ - -import fs from 'fs/promises'; -import kuzu from 'kuzu'; - -/** Per-repo pool: one Database, many Connections */ -interface PoolEntry { - db: kuzu.Database; - /** Available connections ready for checkout */ - available: kuzu.Connection[]; - /** Number of connections currently checked out */ - checkedOut: number; - /** Queued waiters for when all connections are busy */ - waiters: Array<(conn: kuzu.Connection) => void>; - lastUsed: number; - dbPath: string; -} - -const pool = new Map<string, PoolEntry>(); - -/** Max repos in the pool (LRU eviction) */ -const MAX_POOL_SIZE = 5; -/** Idle timeout before closing a repo's connections */ -const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes -/** Max connections per repo (caps concurrent queries per repo) */ -const MAX_CONNS_PER_REPO = 8; -/** Connections created eagerly on init */ -const INITIAL_CONNS_PER_REPO = 2; - -let idleTimer: ReturnType<typeof setInterval> | null = null; - -/** - * Start the idle cleanup timer (runs every 60s) - */ -function ensureIdleTimer(): void { - if (idleTimer) return; - idleTimer = setInterval(() => { - const now = Date.now(); - for (const [repoId, entry] of pool) { - if (now - entry.lastUsed > IDLE_TIMEOUT_MS) { - closeOne(repoId); - } - } - }, 60_000); - if (idleTimer && typeof idleTimer === 'object' && 'unref' in idleTimer) { - (idleTimer as NodeJS.Timeout).unref(); - } -} - -/** - * Evict the least-recently-used repo if pool is at capacity - */ -function evictLRU(): void { - if (pool.size < MAX_POOL_SIZE) return; - - let oldestId: string | null = null; - let oldestTime = Infinity; - for (const [id, entry] of pool) { - if (entry.lastUsed < oldestTime) { - oldestTime = entry.lastUsed; - oldestId = id; - } - } - if (oldestId) { - closeOne(oldestId); - } -} - -/** - * Close all connections for a repo and remove it from the pool - */ -function closeOne(repoId: string): void { - const entry = pool.get(repoId); - if (!entry) return; - for (const conn of entry.available) { - try { conn.close(); } catch {} - } - try { entry.db.close(); } catch {} - pool.delete(repoId); -} - -/** - * Create a new Connection from a repo's Database. - * Silences stdout to prevent native module output from corrupting MCP stdio. - */ -function createConnection(db: kuzu.Database): kuzu.Connection { - const origWrite = process.stdout.write; - process.stdout.write = (() => true) as any; - try { - return new kuzu.Connection(db); - } finally { - process.stdout.write = origWrite; - } -} - -const LOCK_RETRY_ATTEMPTS = 3; -const LOCK_RETRY_DELAY_MS = 2000; - -/** - * Initialize (or reuse) a Database + connection pool for a specific repo. - * Retries on lock errors (e.g., when `gitnexus analyze` is running). - */ -export const initKuzu = async (repoId: string, dbPath: string): Promise<void> => { - const existing = pool.get(repoId); - if (existing) { - existing.lastUsed = Date.now(); - return; - } - - // Check if database exists - try { - await fs.stat(dbPath); - } catch { - throw new Error(`KuzuDB not found at ${dbPath}. Run: gitnexus analyze`); - } - - evictLRU(); - - // Open in read-only mode — MCP server never writes to the database. - // This allows multiple MCP server instances to read concurrently, and - // avoids lock conflicts when `gitnexus analyze` is writing. - let lastError: Error | null = null; - for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) { - const origWrite = process.stdout.write; - process.stdout.write = (() => true) as any; - try { - const db = new kuzu.Database( - dbPath, - 0, // bufferManagerSize (default) - false, // enableCompression (default) - true, // readOnly - ); - process.stdout.write = origWrite; - - // Pre-create a small pool of connections - const available: kuzu.Connection[] = []; - for (let i = 0; i < INITIAL_CONNS_PER_REPO; i++) { - available.push(createConnection(db)); - } - - pool.set(repoId, { db, available, checkedOut: 0, waiters: [], lastUsed: Date.now(), dbPath }); - ensureIdleTimer(); - return; - } catch (err: any) { - process.stdout.write = origWrite; - lastError = err instanceof Error ? err : new Error(String(err)); - const isLockError = lastError.message.includes('Could not set lock') - || lastError.message.includes('lock'); - if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS) break; - await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt)); - } - } - - throw new Error( - `KuzuDB unavailable for ${repoId}. Another process may be rebuilding the index. ` + - `Retry later. (${lastError?.message || 'unknown error'})` - ); -}; - -/** - * Checkout a connection from the pool. - * Returns an available connection, or creates a new one if under the cap. - * If all connections are busy and at cap, queues the caller until one is returned. - */ -function checkout(entry: PoolEntry): Promise<kuzu.Connection> { - // Fast path: grab an available connection - if (entry.available.length > 0) { - entry.checkedOut++; - return Promise.resolve(entry.available.pop()!); - } - - // Grow the pool if under the cap - const totalConns = entry.available.length + entry.checkedOut; - if (totalConns < MAX_CONNS_PER_REPO) { - entry.checkedOut++; - return Promise.resolve(createConnection(entry.db)); - } - - // At capacity — queue the caller. checkin() will resolve this when - // a connection is returned, handing it directly to the next waiter. - return new Promise<kuzu.Connection>(resolve => { - entry.waiters.push(resolve); - }); -} - -/** - * Return a connection to the pool after use. - * If there are queued waiters, hand the connection directly to the next one - * instead of putting it back in the available array (avoids race conditions). - */ -function checkin(entry: PoolEntry, conn: kuzu.Connection): void { - if (entry.waiters.length > 0) { - // Hand directly to the next waiter — no intermediate available state - const waiter = entry.waiters.shift()!; - waiter(conn); - } else { - entry.checkedOut--; - entry.available.push(conn); - } -} - -/** - * Execute a query on a specific repo's connection pool. - * Automatically checks out a connection, runs the query, and returns it. - */ -export const executeQuery = async (repoId: string, cypher: string): Promise<any[]> => { - const entry = pool.get(repoId); - if (!entry) { - throw new Error(`KuzuDB not initialized for repo "${repoId}". Call initKuzu first.`); - } - - entry.lastUsed = Date.now(); - - const conn = await checkout(entry); - try { - const queryResult = await conn.query(cypher); - const result = Array.isArray(queryResult) ? queryResult[0] : queryResult; - const rows = await result.getAll(); - return rows; - } finally { - checkin(entry, conn); - } -}; - -/** - * Close one or all repo pools. - * If repoId is provided, close only that repo's connections. - * If omitted, close all repos. - */ -export const closeKuzu = async (repoId?: string): Promise<void> => { - if (repoId) { - closeOne(repoId); - return; - } - - for (const id of [...pool.keys()]) { - closeOne(id); - } - - if (idleTimer) { - clearInterval(idleTimer); - idleTimer = null; - } -}; - -/** - * Check if a specific repo's pool is active - */ -export const isKuzuReady = (repoId: string): boolean => pool.has(repoId); diff --git a/gitnexus/src/mcp/core/lbug-adapter.ts b/gitnexus/src/mcp/core/lbug-adapter.ts new file mode 100644 index 0000000000..cf9bb1ad69 --- /dev/null +++ b/gitnexus/src/mcp/core/lbug-adapter.ts @@ -0,0 +1,536 @@ +/** + * LadybugDB Adapter (Connection Pool) + * + * Manages a pool of LadybugDB databases keyed by repoId, each with + * multiple Connection objects for safe concurrent query execution. + * + * LadybugDB Connections are NOT thread-safe — a single Connection + * segfaults if concurrent .query() calls hit it simultaneously. + * This adapter provides a checkout/return connection pool so each + * concurrent query gets its own Connection from the same Database. + * + * @see https://docs.ladybugdb.com/concurrency — multiple Connections + * from the same Database is the officially supported concurrency pattern. + */ + +import fs from 'fs/promises'; +import lbug from '@ladybugdb/core'; + +/** Per-repo pool: one Database, many Connections */ +interface PoolEntry { + db: lbug.Database; + /** Available connections ready for checkout */ + available: lbug.Connection[]; + /** Number of connections currently checked out */ + checkedOut: number; + /** Queued waiters for when all connections are busy */ + waiters: Array<(conn: lbug.Connection) => void>; + lastUsed: number; + dbPath: string; + /** Set to true when the pool entry is closed — checkin will close orphaned connections */ + closed: boolean; +} + +const pool = new Map<string, PoolEntry>(); + +/** + * Shared Database cache keyed by resolved dbPath. + * Multiple repoIds pointing to the same path share one native Database + * object to avoid exhausting the buffer manager's mmap budget. + */ +interface SharedDB { + db: lbug.Database; + refCount: number; + ftsLoaded: boolean; + /** When true, closeOne skips db.close() — the Database is owned externally. */ + external?: boolean; +} +const dbCache = new Map<string, SharedDB>(); + +/** Max repos in the pool (LRU eviction) */ +const MAX_POOL_SIZE = 5; +/** Idle timeout before closing a repo's connections */ +const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes +/** Max connections per repo (caps concurrent queries per repo) */ +const MAX_CONNS_PER_REPO = 8; + +let idleTimer: ReturnType<typeof setInterval> | null = null; + +/** Saved real stdout.write — used to silence LadybugDB native output without race conditions */ +export const realStdoutWrite = process.stdout.write.bind(process.stdout); +let stdoutSilenceCount = 0; +/** True while pre-warming connections — prevents watchdog from prematurely restoring stdout */ +let preWarmActive = false; + +/** + * Start the idle cleanup timer (runs every 60s) + */ +function ensureIdleTimer(): void { + if (idleTimer) return; + idleTimer = setInterval(() => { + const now = Date.now(); + for (const [repoId, entry] of pool) { + if (now - entry.lastUsed > IDLE_TIMEOUT_MS && entry.checkedOut === 0) { + closeOne(repoId); + } + } + }, 60_000); + if (idleTimer && typeof idleTimer === 'object' && 'unref' in idleTimer) { + (idleTimer as NodeJS.Timeout).unref(); + } +} + +/** + * Evict the least-recently-used repo if pool is at capacity + */ +function evictLRU(): void { + if (pool.size < MAX_POOL_SIZE) return; + + let oldestId: string | null = null; + let oldestTime = Infinity; + for (const [id, entry] of pool) { + if (entry.checkedOut === 0 && entry.lastUsed < oldestTime) { + oldestTime = entry.lastUsed; + oldestId = id; + } + } + if (oldestId) { + closeOne(oldestId); + } +} + +/** + * Remove a repo from the pool, close its connections, and release its + * shared Database ref. Only closes the Database when no other repoIds + * reference it (refCount === 0). + */ +function closeOne(repoId: string): void { + const entry = pool.get(repoId); + if (!entry) return; + + entry.closed = true; + + // Close available connections — fire-and-forget with .catch() to prevent + // unhandled rejections. Native close() returns Promise<void> but can crash + // the N-API destructor on macOS/Windows; deferring to process exit lets + // dangerouslyIgnoreUnhandledErrors absorb the crash. + for (const conn of entry.available) { + conn.close().catch(() => {}); + } + entry.available.length = 0; + + // Checked-out connections can't be closed here — they're in-flight. + // The checkin() function detects entry.closed and closes them on return. + + // Only close the Database when no other repoIds reference it. + // External databases (injected via initLbugWithDb) are never closed here — + // the core adapter owns them and handles their lifecycle. + const shared = dbCache.get(entry.dbPath); + if (shared) { + shared.refCount--; + if (shared.refCount === 0) { + if (shared.external) { + // External databases are owned by the core adapter — don't close + // or remove from cache. Keep the entry so future initLbug() calls + // for the same dbPath reuse it instead of hitting a file lock. + shared.refCount = 0; + } else { + shared.db.close().catch(() => {}); + dbCache.delete(entry.dbPath); + } + } + } + + pool.delete(repoId); +} + +/** + * Create a new Connection from a repo's Database. + * Silences stdout to prevent native module output from corrupting MCP stdio. + */ +function silenceStdout(): void { + if (stdoutSilenceCount++ === 0) { + process.stdout.write = (() => true) as any; + } +} + +function restoreStdout(): void { + if (--stdoutSilenceCount <= 0) { + stdoutSilenceCount = 0; + process.stdout.write = realStdoutWrite; + } +} + +// Safety watchdog: restore stdout if it gets stuck silenced (e.g. native crash +// inside createConnection before restoreStdout runs). +setInterval(() => { + if (stdoutSilenceCount > 0 && !preWarmActive) { + stdoutSilenceCount = 0; + process.stdout.write = realStdoutWrite; + } +}, 1000).unref(); + +function createConnection(db: lbug.Database): lbug.Connection { + silenceStdout(); + try { + return new lbug.Connection(db); + } finally { + restoreStdout(); + } +} + +/** Query timeout in milliseconds */ +const QUERY_TIMEOUT_MS = 30_000; +/** Waiter queue timeout in milliseconds */ +const WAITER_TIMEOUT_MS = 15_000; + +const LOCK_RETRY_ATTEMPTS = 3; +const LOCK_RETRY_DELAY_MS = 2000; + +/** Deduplicates concurrent initLbug calls for the same repoId */ +const initPromises = new Map<string, Promise<void>>(); + +/** + * Initialize (or reuse) a Database + connection pool for a specific repo. + * Retries on lock errors (e.g., when `gitnexus analyze` is running). + * + * Concurrent calls for the same repoId are deduplicated — the second caller + * awaits the first's in-progress init rather than starting a redundant one. + */ +export const initLbug = async (repoId: string, dbPath: string): Promise<void> => { + const existing = pool.get(repoId); + if (existing) { + existing.lastUsed = Date.now(); + return; + } + + // Deduplicate concurrent init calls for the same repoId — + // prevents double-init race when multiple parallel tool calls + // trigger initialization for the same repo simultaneously. + const pending = initPromises.get(repoId); + if (pending) return pending; + + const promise = doInitLbug(repoId, dbPath); + initPromises.set(repoId, promise); + try { + await promise; + } finally { + initPromises.delete(repoId); + } +}; + +/** + * Internal init — creates DB, pre-warms connections, loads FTS, then registers pool. + * Pool entry is registered LAST so concurrent executeQuery calls see either + * "not initialized" (and throw) or a fully ready pool — never a half-built one. + */ +async function doInitLbug(repoId: string, dbPath: string): Promise<void> { + // Check if database exists + try { + await fs.stat(dbPath); + } catch { + throw new Error(`LadybugDB not found at ${dbPath}. Run: gitnexus analyze`); + } + + evictLRU(); + + // Reuse an existing native Database if another repoId already opened this path. + // This prevents buffer manager exhaustion from multiple mmap regions on the same file. + let shared = dbCache.get(dbPath); + if (!shared) { + // Open in read-only mode — MCP server never writes to the database. + // This allows multiple MCP server instances to read concurrently, and + // avoids lock conflicts when `gitnexus analyze` is writing. + let lastError: Error | null = null; + for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) { + silenceStdout(); + try { + const db = new lbug.Database( + dbPath, + 0, // bufferManagerSize (default) + false, // enableCompression (default) + true, // readOnly + ); + restoreStdout(); + shared = { db, refCount: 0, ftsLoaded: false }; + dbCache.set(dbPath, shared); + break; + } catch (err: any) { + restoreStdout(); + lastError = err instanceof Error ? err : new Error(String(err)); + const isLockError = lastError.message.includes('Could not set lock') + || lastError.message.includes('lock'); + if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS) break; + await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt)); + } + } + + if (!shared) { + throw new Error( + `LadybugDB unavailable for ${repoId}. Another process may be rebuilding the index. ` + + `Retry later. (${lastError?.message || 'unknown error'})` + ); + } + } + + shared.refCount++; + const db = shared.db; + + // Pre-create the full pool upfront so createConnection() (which silences + // stdout) is never called lazily during active query execution. + // Mark preWarmActive so the watchdog timer doesn't interfere. + preWarmActive = true; + const available: lbug.Connection[] = []; + try { + for (let i = 0; i < MAX_CONNS_PER_REPO; i++) { + available.push(createConnection(db)); + } + } finally { + preWarmActive = false; + } + + // Load FTS extension once per shared Database. + // Done BEFORE pool registration so no concurrent checkout can grab + // the connection while the async FTS load is in progress. + if (!shared.ftsLoaded) { + try { + await available[0].query('LOAD EXTENSION fts'); + shared.ftsLoaded = true; + } catch { + // Extension may not be installed — FTS queries will fail gracefully + } + } + + // Register pool entry only after all connections are pre-warmed and FTS is + // loaded. Concurrent executeQuery calls see either "not initialized" + // (and throw cleanly) or a fully ready pool — never a half-built one. + pool.set(repoId, { db, available, checkedOut: 0, waiters: [], lastUsed: Date.now(), dbPath, closed: false }); + ensureIdleTimer(); +} + +/** + * Initialize a pool entry from a pre-existing Database object. + * + * Used in tests to avoid the writable→close→read-only cycle that crashes + * on macOS due to N-API destructor segfaults. The pool adapter reuses + * the core adapter's writable Database instead of opening a new read-only one. + * + * The Database is registered in the shared dbCache so closeOne() decrements + * the refCount correctly. If the Database is already cached (e.g. another + * repoId already injected it), the existing entry is reused. + */ +export async function initLbugWithDb( + repoId: string, + existingDb: lbug.Database, + dbPath: string, +): Promise<void> { + const existing = pool.get(repoId); + if (existing) { + existing.lastUsed = Date.now(); + return; + } + + // Register in dbCache with external: true so other initLbug() calls + // for the same dbPath reuse this Database instead of trying to open + // a new one (which would fail with a file lock error). + // closeOne() respects the external flag and skips db.close(). + let shared = dbCache.get(dbPath); + if (!shared) { + shared = { db: existingDb, refCount: 0, ftsLoaded: false, external: true }; + dbCache.set(dbPath, shared); + } + shared.refCount++; + + const available: lbug.Connection[] = []; + preWarmActive = true; + try { + for (let i = 0; i < MAX_CONNS_PER_REPO; i++) { + available.push(createConnection(existingDb)); + } + } finally { + preWarmActive = false; + } + + // Load FTS extension if not already loaded on this Database + try { + await available[0].query('LOAD EXTENSION fts'); + } catch { + // Extension may already be loaded or not installed + } + + pool.set(repoId, { + db: existingDb, + available, + checkedOut: 0, + waiters: [], + lastUsed: Date.now(), + dbPath, + closed: false + }); + ensureIdleTimer(); +} + +/** + * Checkout a connection from the pool. + * Returns an available connection, or creates a new one if under the cap. + * If all connections are busy and at cap, queues the caller until one is returned. + */ +function checkout(entry: PoolEntry): Promise<lbug.Connection> { + // Fast path: grab an available connection + if (entry.available.length > 0) { + entry.checkedOut++; + return Promise.resolve(entry.available.pop()!); + } + + // Pool was pre-warmed to MAX_CONNS_PER_REPO during init. If we're here + // with fewer total connections, something leaked — surface the bug rather + // than silently creating a connection (which would silence stdout mid-query). + const totalConns = entry.available.length + entry.checkedOut; + if (totalConns < MAX_CONNS_PER_REPO) { + throw new Error( + `Connection pool integrity error: expected ${MAX_CONNS_PER_REPO} ` + + `connections but found ${totalConns} (${entry.available.length} available, ` + + `${entry.checkedOut} checked out)` + ); + } + + // At capacity — queue the caller with a timeout. + return new Promise<lbug.Connection>((resolve, reject) => { + const waiter = (conn: lbug.Connection) => { + clearTimeout(timer); + resolve(conn); + }; + const timer = setTimeout(() => { + const idx = entry.waiters.indexOf(waiter); + if (idx !== -1) entry.waiters.splice(idx, 1); + reject(new Error(`Connection pool exhausted: timed out after ${WAITER_TIMEOUT_MS}ms waiting for a free connection`)); + }, WAITER_TIMEOUT_MS); + entry.waiters.push(waiter); + }); +} + +/** + * Return a connection to the pool after use. + * If the pool entry was closed while the connection was checked out (e.g. + * LRU eviction), close the orphaned connection instead of returning it. + * If there are queued waiters, hand the connection directly to the next one + * instead of putting it back in the available array (avoids race conditions). + */ +function checkin(entry: PoolEntry, conn: lbug.Connection): void { + if (entry.closed) { + // Pool entry was deleted during checkout — close the orphaned connection + conn.close().catch(() => {}); + return; + } + if (entry.waiters.length > 0) { + // Hand directly to the next waiter — no intermediate available state + const waiter = entry.waiters.shift()!; + waiter(conn); + } else { + entry.checkedOut--; + entry.available.push(conn); + } +} + +/** + * Execute a query on a specific repo's connection pool. + * Automatically checks out a connection, runs the query, and returns it. + */ +/** Race a promise against a timeout */ +function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> { + let timer: ReturnType<typeof setTimeout>; + const timeout = new Promise<never>((_, reject) => { + timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms); + }); + return Promise.race([promise, timeout]).finally(() => clearTimeout(timer)); +} + +export const executeQuery = async (repoId: string, cypher: string): Promise<any[]> => { + const entry = pool.get(repoId); + if (!entry) { + throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`); + } + + if (isWriteQuery(cypher)) { + throw new Error('Write operations are not allowed. The pool adapter is read-only.'); + } + + entry.lastUsed = Date.now(); + + const conn = await checkout(entry); + try { + const queryResult = await withTimeout(conn.query(cypher), QUERY_TIMEOUT_MS, 'Query'); + const result = Array.isArray(queryResult) ? queryResult[0] : queryResult; + const rows = await result.getAll(); + return rows; + } finally { + checkin(entry, conn); + } +}; + +/** + * Execute a parameterized query on a specific repo's connection pool. + * Uses prepare/execute pattern to prevent Cypher injection. + */ +export const executeParameterized = async ( + repoId: string, + cypher: string, + params: Record<string, any>, +): Promise<any[]> => { + const entry = pool.get(repoId); + if (!entry) { + throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`); + } + + entry.lastUsed = Date.now(); + + const conn = await checkout(entry); + try { + const stmt = await withTimeout(conn.prepare(cypher), QUERY_TIMEOUT_MS, 'Prepare'); + if (!stmt.isSuccess()) { + const errMsg = await stmt.getErrorMessage(); + throw new Error(`Prepare failed: ${errMsg}`); + } + const queryResult = await withTimeout(conn.execute(stmt, params), QUERY_TIMEOUT_MS, 'Execute'); + const result = Array.isArray(queryResult) ? queryResult[0] : queryResult; + const rows = await result.getAll(); + return rows; + } finally { + checkin(entry, conn); + } +}; + +/** + * Close one or all repo pools. + * If repoId is provided, close only that repo's connections. + * If omitted, close all repos. + */ +export const closeLbug = async (repoId?: string): Promise<void> => { + if (repoId) { + closeOne(repoId); + return; + } + + for (const id of [...pool.keys()]) { + closeOne(id); + } + + if (idleTimer) { + clearInterval(idleTimer); + idleTimer = null; + } +}; + + +/** + * Check if a specific repo's pool is active + */ +export const isLbugReady = (repoId: string): boolean => pool.has(repoId); + +/** Regex to detect write operations in user-supplied Cypher queries */ +export const CYPHER_WRITE_RE = /\b(CREATE|DELETE|SET|MERGE|REMOVE|DROP|ALTER|COPY|DETACH)\b/i; + +/** Check if a Cypher query contains write operations */ +export function isWriteQuery(query: string): boolean { + return CYPHER_WRITE_RE.test(query); +} diff --git a/gitnexus/src/mcp/local/local-backend.ts b/gitnexus/src/mcp/local/local-backend.ts index c47560d2b6..bb7a4f6f1c 100644 --- a/gitnexus/src/mcp/local/local-backend.ts +++ b/gitnexus/src/mcp/local/local-backend.ts @@ -3,17 +3,19 @@ * * Provides tool implementations using local .gitnexus/ indexes. * Supports multiple indexed repositories via a global registry. - * KuzuDB connections are opened lazily per repo on first query. + * LadybugDB connections are opened lazily per repo on first query. */ import fs from 'fs/promises'; import path from 'path'; -import { initKuzu, executeQuery, closeKuzu, isKuzuReady } from '../core/kuzu-adapter.js'; -import { embedQuery, getEmbeddingDims, disposeEmbedder } from '../core/embedder.js'; +import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady } from '../core/lbug-adapter.js'; +// Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node +// at MCP server startup — crashes on unsupported Node ABI versions (#89) // git utilities available if needed // import { isGitRepo, getCurrentCommit, getGitRoot } from '../../storage/git.js'; import { listRegisteredRepos, + cleanupOldKuzuFiles, type RegistryEntry, } from '../../storage/repo-manager.js'; // AI context generation is CLI-only (gitnexus analyze) @@ -23,7 +25,7 @@ import { * Quick test-file detection for filtering impact results. * Matches common test file patterns across all supported languages. */ -function isTestFilePath(filePath: string): boolean { +export function isTestFilePath(filePath: string): boolean { const p = filePath.toLowerCase().replace(/\\/g, '/'); return ( p.includes('.test.') || p.includes('.spec.') || @@ -31,18 +33,36 @@ function isTestFilePath(filePath: string): boolean { p.includes('/test/') || p.includes('/tests/') || p.includes('/testing/') || p.includes('/fixtures/') || p.endsWith('_test.go') || p.endsWith('_test.py') || + p.endsWith('_spec.rb') || p.endsWith('_test.rb') || p.includes('/spec/') || p.includes('/test_') || p.includes('/conftest.') ); } -/** Valid KuzuDB node labels for safe Cypher query construction */ -const VALID_NODE_LABELS = new Set([ +/** Valid LadybugDB node labels for safe Cypher query construction */ +export const VALID_NODE_LABELS = new Set([ 'File', 'Folder', 'Function', 'Class', 'Interface', 'Method', 'CodeElement', 'Community', 'Process', 'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl', 'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module', ]); +/** Valid relation types for impact analysis filtering */ +export const VALID_RELATION_TYPES = new Set(['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'OVERRIDES', 'ACCESSES']); + +/** Regex to detect write operations in user-supplied Cypher queries */ +export const CYPHER_WRITE_RE = /\b(CREATE|DELETE|SET|MERGE|REMOVE|DROP|ALTER|COPY|DETACH)\b/i; + +/** Check if a Cypher query contains write operations */ +export function isWriteQuery(query: string): boolean { + return CYPHER_WRITE_RE.test(query); +} + +/** Structured error logging for query failures — replaces empty catch blocks */ +function logQueryError(context: string, err: unknown): void { + const msg = err instanceof Error ? err.message : String(err); + console.error(`GitNexus [${context}]: ${msg}`); +} + export interface CodebaseContext { projectName: string; stats: { @@ -58,7 +78,7 @@ interface RepoHandle { name: string; repoPath: string; storagePath: string; - kuzuPath: string; + lbugPath: string; indexedAt: string; lastCommit: string; stats?: RegistryEntry['stats']; @@ -83,7 +103,7 @@ export class LocalBackend { /** * Re-read the global registry and update the in-memory repo map. * New repos are added, existing repos are updated, removed repos are pruned. - * KuzuDB connections for removed repos are NOT closed (they idle-timeout naturally). + * LadybugDB connections for removed repos are NOT closed (they idle-timeout naturally). */ private async refreshRepos(): Promise<void> { const entries = await listRegisteredRepos({ validate: true }); @@ -94,14 +114,21 @@ export class LocalBackend { freshIds.add(id); const storagePath = entry.storagePath; - const kuzuPath = path.join(storagePath, 'kuzu'); + const lbugPath = path.join(storagePath, 'lbug'); + + // Clean up any leftover KuzuDB files from before the LadybugDB migration. + // If kuzu exists but lbug doesn't, warn so the user knows to re-analyze. + const kuzu = await cleanupOldKuzuFiles(storagePath); + if (kuzu.found && kuzu.needsReindex) { + console.error(`GitNexus: "${entry.name}" has a stale KuzuDB index. Run: gitnexus analyze ${entry.path}`); + } const handle: RepoHandle = { id, name: entry.name, repoPath: entry.path, storagePath, - kuzuPath, + lbugPath, indexedAt: entry.indexedAt, lastCommit: entry.lastCommit, stats: entry.stats, @@ -109,7 +136,7 @@ export class LocalBackend { this.repos.set(id, handle); - // Build lightweight context (no KuzuDB needed) + // Build lightweight context (no LadybugDB needed) const s = entry.stats || {}; this.contextCache.set(id, { projectName: entry.name, @@ -216,17 +243,17 @@ export class LocalBackend { return null; // Multiple repos, no param — ambiguous } - // ─── Lazy KuzuDB Init ──────────────────────────────────────────── + // ─── Lazy LadybugDB Init ──────────────────────────────────────────── private async ensureInitialized(repoId: string): Promise<void> { // Always check the actual pool — the idle timer may have evicted the connection - if (this.initializedRepos.has(repoId) && isKuzuReady(repoId)) return; + if (this.initializedRepos.has(repoId) && isLbugReady(repoId)) return; const handle = this.repos.get(repoId); if (!handle) throw new Error(`Unknown repo: ${repoId}`); try { - await initKuzu(repoId, handle.kuzuPath); + await initLbug(repoId, handle.lbugPath); this.initializedRepos.add(repoId); } catch (err: any) { // If lock error, mark as not initialized so next call retries @@ -386,46 +413,44 @@ export class LocalBackend { continue; } - const escaped = sym.nodeId.replace(/'/g, "''"); - // Find processes this symbol participates in let processRows: any[] = []; try { - processRows = await executeQuery(repo.id, ` - MATCH (n {id: '${escaped}'})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) + processRows = await executeParameterized(repo.id, ` + MATCH (n {id: $nodeId})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) RETURN p.id AS pid, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount, r.step AS step - `); - } catch { /* symbol might not be in any process */ } - + `, { nodeId: sym.nodeId }); + } catch (e) { logQueryError('query:process-lookup', e); } + // Get cluster membership + cohesion (cohesion used as internal ranking signal) let cohesion = 0; let module: string | undefined; try { - const cohesionRows = await executeQuery(repo.id, ` - MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) + const cohesionRows = await executeParameterized(repo.id, ` + MATCH (n {id: $nodeId})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) RETURN c.cohesion AS cohesion, c.heuristicLabel AS module LIMIT 1 - `); + `, { nodeId: sym.nodeId }); if (cohesionRows.length > 0) { cohesion = (cohesionRows[0].cohesion ?? cohesionRows[0][0]) || 0; module = cohesionRows[0].module ?? cohesionRows[0][1]; } - } catch { /* no cluster info */ } - + } catch (e) { logQueryError('query:cluster-info', e); } + // Optionally fetch content let content: string | undefined; if (includeContent) { try { - const contentRows = await executeQuery(repo.id, ` - MATCH (n {id: '${escaped}'}) + const contentRows = await executeParameterized(repo.id, ` + MATCH (n {id: $nodeId}) RETURN n.content AS content - `); + `, { nodeId: sym.nodeId }); if (contentRows.length > 0) { content = contentRows[0].content ?? contentRows[0][0]; } - } catch { /* skip */ } + } catch (e) { logQueryError('query:content-fetch', e); } } - + const symbolEntry = { id: sym.nodeId, name: sym.name, @@ -517,13 +542,13 @@ export class LocalBackend { } /** - * BM25 keyword search helper - uses KuzuDB FTS for always-fresh results + * BM25 keyword search helper - uses LadybugDB FTS for always-fresh results */ private async bm25Search(repo: RepoHandle, query: string, limit: number): Promise<any[]> { - const { searchFTSFromKuzu } = await import('../../core/search/bm25-index.js'); + const { searchFTSFromLbug } = await import('../../core/search/bm25-index.js'); let bm25Results; try { - bm25Results = await searchFTSFromKuzu(query, limit, repo.id); + bm25Results = await searchFTSFromLbug(query, limit, repo.id); } catch (err: any) { console.error('GitNexus: BM25/FTS search failed (FTS indexes may not exist) -', err.message); return []; @@ -534,13 +559,12 @@ export class LocalBackend { for (const bm25Result of bm25Results) { const fullPath = bm25Result.filePath; try { - const symbolQuery = ` - MATCH (n) - WHERE n.filePath = '${fullPath.replace(/'/g, "''")}' + const symbols = await executeParameterized(repo.id, ` + MATCH (n) + WHERE n.filePath = $filePath RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine LIMIT 3 - `; - const symbols = await executeQuery(repo.id, symbolQuery); + `, { filePath: fullPath }); if (symbols.length > 0) { for (const sym of symbols) { @@ -586,6 +610,7 @@ export class LocalBackend { const tableCheck = await executeQuery(repo.id, `MATCH (e:CodeEmbedding) RETURN COUNT(*) AS cnt LIMIT 1`); if (!tableCheck.length || (tableCheck[0].cnt ?? tableCheck[0][0]) === 0) return []; + const { embedQuery, getEmbeddingDims } = await import('../core/embedder.js'); const queryVec = await embedQuery(query); const dims = getEmbeddingDims(); const queryVecStr = `[${queryVec.join(',')}]`; @@ -617,12 +642,11 @@ export class LocalBackend { if (!VALID_NODE_LABELS.has(label)) continue; try { - const escapedId = nodeId.replace(/'/g, "''"); const nodeQuery = label === 'File' - ? `MATCH (n:File {id: '${escapedId}'}) RETURN n.name AS name, n.filePath AS filePath` - : `MATCH (n:\`${label}\` {id: '${escapedId}'}) RETURN n.name AS name, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine`; - - const nodeRows = await executeQuery(repo.id, nodeQuery); + ? `MATCH (n:File {id: $nodeId}) RETURN n.name AS name, n.filePath AS filePath` + : `MATCH (n:\`${label}\` {id: $nodeId}) RETURN n.name AS name, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine`; + + const nodeRows = await executeParameterized(repo.id, nodeQuery, { nodeId }); if (nodeRows.length > 0) { const nodeRow = nodeRows[0]; results.push({ @@ -653,8 +677,13 @@ export class LocalBackend { private async cypher(repo: RepoHandle, params: { query: string }): Promise<any> { await this.ensureInitialized(repo.id); - if (!isKuzuReady(repo.id)) { - return { error: 'KuzuDB not ready. Index may be corrupted.' }; + if (!isLbugReady(repo.id)) { + return { error: 'LadybugDB not ready. Index may be corrupted.' }; + } + + // Block write operations (defense-in-depth — DB is already read-only) + if (CYPHER_WRITE_RE.test(params.query)) { + return { error: 'Write operations (CREATE, DELETE, SET, MERGE, REMOVE, DROP, ALTER, COPY, DETACH) are not allowed. The knowledge graph is read-only.' }; } try { @@ -698,7 +727,7 @@ export class LocalBackend { /** * Aggregate same-named clusters: group by heuristicLabel, sum symbols, * weighted-average cohesion, filter out tiny clusters (<5 symbols). - * Raw communities stay intact in KuzuDB for Cypher queries. + * Raw communities stay intact in LadybugDB for Cypher queries. */ private aggregateClusters(clusters: any[]): any[] { const groups = new Map<string, { ids: string[]; totalSymbols: number; weightedCohesion: number; largest: any }>(); @@ -815,31 +844,32 @@ export class LocalBackend { let symbols: any[]; if (uid) { - const escaped = uid.replace(/'/g, "''"); - symbols = await executeQuery(repo.id, ` - MATCH (n {id: '${escaped}'}) + symbols = await executeParameterized(repo.id, ` + MATCH (n {id: $uid}) RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine${include_content ? ', n.content AS content' : ''} LIMIT 1 - `); + `, { uid }); } else { - const escaped = name!.replace(/'/g, "''"); const isQualified = name!.includes('/') || name!.includes(':'); - + let whereClause: string; + let queryParams: Record<string, any>; if (file_path) { - const fpEscaped = file_path.replace(/'/g, "''"); - whereClause = `WHERE n.name = '${escaped}' AND n.filePath CONTAINS '${fpEscaped}'`; + whereClause = `WHERE n.name = $symName AND n.filePath CONTAINS $filePath`; + queryParams = { symName: name!, filePath: file_path }; } else if (isQualified) { - whereClause = `WHERE n.id = '${escaped}' OR n.name = '${escaped}'`; + whereClause = `WHERE n.id = $symName OR n.name = $symName`; + queryParams = { symName: name! }; } else { - whereClause = `WHERE n.name = '${escaped}'`; + whereClause = `WHERE n.name = $symName`; + queryParams = { symName: name! }; } - - symbols = await executeQuery(repo.id, ` + + symbols = await executeParameterized(repo.id, ` MATCH (n) ${whereClause} RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine${include_content ? ', n.content AS content' : ''} LIMIT 10 - `); + `, queryParams); } if (symbols.length === 0) { @@ -863,32 +893,32 @@ export class LocalBackend { // Step 3: Build full context const sym = symbols[0]; - const symId = (sym.id || sym[0]).replace(/'/g, "''"); - + const symId = sym.id || sym[0]; + // Categorized incoming refs - const incomingRows = await executeQuery(repo.id, ` - MATCH (caller)-[r:CodeRelation]->(n {id: '${symId}'}) - WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS'] + const incomingRows = await executeParameterized(repo.id, ` + MATCH (caller)-[r:CodeRelation]->(n {id: $symId}) + WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'OVERRIDES', 'ACCESSES'] RETURN r.type AS relType, caller.id AS uid, caller.name AS name, caller.filePath AS filePath, labels(caller)[0] AS kind LIMIT 30 - `); - + `, { symId }); + // Categorized outgoing refs - const outgoingRows = await executeQuery(repo.id, ` - MATCH (n {id: '${symId}'})-[r:CodeRelation]->(target) - WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS'] + const outgoingRows = await executeParameterized(repo.id, ` + MATCH (n {id: $symId})-[r:CodeRelation]->(target) + WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'OVERRIDES', 'ACCESSES'] RETURN r.type AS relType, target.id AS uid, target.name AS name, target.filePath AS filePath, labels(target)[0] AS kind LIMIT 30 - `); - + `, { symId }); + // Process participation let processRows: any[] = []; try { - processRows = await executeQuery(repo.id, ` - MATCH (n {id: '${symId}'})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) + processRows = await executeParameterized(repo.id, ` + MATCH (n {id: $symId})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) RETURN p.id AS pid, p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount - `); - } catch { /* no process info */ } + `, { symId }); + } catch (e) { logQueryError('context:process-participation', e); } // Helper to categorize refs const categorize = (rows: any[]) => { @@ -942,33 +972,31 @@ export class LocalBackend { } if (type === 'cluster') { - const escaped = name.replace(/'/g, "''"); - const clusterQuery = ` + const clusters = await executeParameterized(repo.id, ` MATCH (c:Community) - WHERE c.label = '${escaped}' OR c.heuristicLabel = '${escaped}' + WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName RETURN c.id AS id, c.label AS label, c.heuristicLabel AS heuristicLabel, c.cohesion AS cohesion, c.symbolCount AS symbolCount - `; - const clusters = await executeQuery(repo.id, clusterQuery); + `, { clusterName: name }); if (clusters.length === 0) return { error: `Cluster '${name}' not found` }; - + const rawClusters = clusters.map((c: any) => ({ id: c.id || c[0], label: c.label || c[1], heuristicLabel: c.heuristicLabel || c[2], cohesion: c.cohesion || c[3], symbolCount: c.symbolCount || c[4], })); - + let totalSymbols = 0, weightedCohesion = 0; for (const c of rawClusters) { const s = c.symbolCount || 0; totalSymbols += s; weightedCohesion += (c.cohesion || 0) * s; } - - const members = await executeQuery(repo.id, ` + + const members = await executeParameterized(repo.id, ` MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) - WHERE c.label = '${escaped}' OR c.heuristicLabel = '${escaped}' + WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName RETURN DISTINCT n.name AS name, labels(n)[0] AS type, n.filePath AS filePath LIMIT 30 - `); + `, { clusterName: name }); return { cluster: { @@ -986,21 +1014,21 @@ export class LocalBackend { } if (type === 'process') { - const processes = await executeQuery(repo.id, ` + const processes = await executeParameterized(repo.id, ` MATCH (p:Process) - WHERE p.label = '${name.replace(/'/g, "''")}' OR p.heuristicLabel = '${name.replace(/'/g, "''")}' + WHERE p.label = $processName OR p.heuristicLabel = $processName RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount LIMIT 1 - `); + `, { processName: name }); if (processes.length === 0) return { error: `Process '${name}' not found` }; - + const proc = processes[0]; const procId = proc.id || proc[0]; - const steps = await executeQuery(repo.id, ` - MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: '${procId}'}) + const steps = await executeParameterized(repo.id, ` + MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: $procId}) RETURN n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, r.step AS step ORDER BY r.step - `); + `, { procId }); return { process: { @@ -1027,30 +1055,30 @@ export class LocalBackend { await this.ensureInitialized(repo.id); const scope = params.scope || 'unstaged'; - const { execSync } = await import('child_process'); - - // Build git diff command based on scope - let diffCmd: string; + const { execFileSync } = await import('child_process'); + + // Build git diff args based on scope (using execFileSync to avoid shell injection) + let diffArgs: string[]; switch (scope) { case 'staged': - diffCmd = 'git diff --staged --name-only'; + diffArgs = ['diff', '--staged', '--name-only']; break; case 'all': - diffCmd = 'git diff HEAD --name-only'; + diffArgs = ['diff', 'HEAD', '--name-only']; break; case 'compare': if (!params.base_ref) return { error: 'base_ref is required for "compare" scope' }; - diffCmd = `git diff ${params.base_ref} --name-only`; + diffArgs = ['diff', params.base_ref, '--name-only']; break; case 'unstaged': default: - diffCmd = 'git diff --name-only'; + diffArgs = ['diff', '--name-only']; break; } - + let changedFiles: string[]; try { - const output = execSync(diffCmd, { cwd: repo.repoPath, encoding: 'utf-8' }); + const output = execFileSync('git', diffArgs, { cwd: repo.repoPath, encoding: 'utf-8' }); changedFiles = output.trim().split('\n').filter(f => f.length > 0); } catch (err: any) { return { error: `Git diff failed: ${err.message}` }; @@ -1067,13 +1095,13 @@ export class LocalBackend { // Map changed files to indexed symbols const changedSymbols: any[] = []; for (const file of changedFiles) { - const escaped = file.replace(/\\/g, '/').replace(/'/g, "''"); + const normalizedFile = file.replace(/\\/g, '/'); try { - const symbols = await executeQuery(repo.id, ` - MATCH (n) WHERE n.filePath CONTAINS '${escaped}' + const symbols = await executeParameterized(repo.id, ` + MATCH (n) WHERE n.filePath CONTAINS $filePath RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath LIMIT 20 - `); + `, { filePath: normalizedFile }); for (const sym of symbols) { changedSymbols.push({ id: sym.id || sym[0], @@ -1083,18 +1111,17 @@ export class LocalBackend { change_type: 'Modified', }); } - } catch { /* skip */ } + } catch (e) { logQueryError('detect-changes:file-symbols', e); } } - + // Find affected processes const affectedProcesses = new Map<string, any>(); for (const sym of changedSymbols) { - const escaped = (sym.id as string).replace(/'/g, "''"); try { - const procs = await executeQuery(repo.id, ` - MATCH (n {id: '${escaped}'})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) + const procs = await executeParameterized(repo.id, ` + MATCH (n {id: $nodeId})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) RETURN p.id AS pid, p.heuristicLabel AS label, p.processType AS processType, p.stepCount AS stepCount, r.step AS step - `); + `, { nodeId: sym.id }); for (const proc of procs) { const pid = proc.pid || proc[0]; if (!affectedProcesses.has(pid)) { @@ -1111,9 +1138,9 @@ export class LocalBackend { step: proc.step || proc[4], }); } - } catch { /* skip */ } + } catch (e) { logQueryError('detect-changes:process-lookup', e); } } - + const processCount = affectedProcesses.size; const risk = processCount === 0 ? 'low' : processCount <= 5 ? 'medium' : processCount <= 15 ? 'high' : 'critical'; @@ -1145,10 +1172,19 @@ export class LocalBackend { const { new_name, file_path } = params; const dry_run = params.dry_run ?? true; - + if (!params.symbol_name && !params.symbol_uid) { return { error: 'Either symbol_name or symbol_uid is required.' }; } + + /** Guard: ensure a file path resolves within the repo root (prevents path traversal) */ + const assertSafePath = (filePath: string): string => { + const full = path.resolve(repo.repoPath, filePath); + if (!full.startsWith(repo.repoPath + path.sep) && full !== repo.repoPath) { + throw new Error(`Path traversal blocked: ${filePath}`); + } + return full; + }; // Step 1: Find the target symbol (reuse context's lookup) const lookupResult = await this.context(repo, { @@ -1184,15 +1220,16 @@ export class LocalBackend { // The definition itself if (sym.filePath && sym.startLine) { try { - const content = await fs.readFile(path.join(repo.repoPath, sym.filePath), 'utf-8'); + const content = await fs.readFile(assertSafePath(sym.filePath), 'utf-8'); const lines = content.split('\n'); const lineIdx = sym.startLine - 1; if (lineIdx >= 0 && lineIdx < lines.length && lines[lineIdx].includes(oldName)) { - addEdit(sym.filePath, sym.startLine, lines[lineIdx].trim(), lines[lineIdx].replace(oldName, new_name).trim(), 'graph'); + const defRegex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g'); + addEdit(sym.filePath, sym.startLine, lines[lineIdx].trim(), lines[lineIdx].replace(defRegex, new_name).trim(), 'graph'); } - } catch { /* skip */ } + } catch (e) { logQueryError('rename:read-definition', e); } } - + // All incoming refs from graph (callers, importers, etc.) const allIncoming = [ ...(lookupResult.incoming.calls || []), @@ -1206,7 +1243,7 @@ export class LocalBackend { for (const ref of allIncoming) { if (!ref.filePath) continue; try { - const content = await fs.readFile(path.join(repo.repoPath, ref.filePath), 'utf-8'); + const content = await fs.readFile(assertSafePath(ref.filePath), 'utf-8'); const lines = content.split('\n'); for (let i = 0; i < lines.length; i++) { if (lines[i].includes(oldName)) { @@ -1215,18 +1252,24 @@ export class LocalBackend { break; // one edit per file from graph refs } } - } catch { /* skip */ } + } catch (e) { logQueryError('rename:read-ref', e); } } - + // Step 3: Text search for refs the graph might have missed let astSearchEdits = 0; const graphFiles = new Set([sym.filePath, ...allIncoming.map(r => r.filePath)].filter(Boolean)); // Simple text search across the repo for the old name (in files not already covered by graph) try { - const { execSync } = await import('child_process'); - const rgCmd = `rg -l --type-add "code:*.{ts,tsx,js,jsx,py,go,rs,java}" -t code "\\b${oldName}\\b" .`; - const output = execSync(rgCmd, { cwd: repo.repoPath, encoding: 'utf-8', timeout: 5000 }); + const { execFileSync } = await import('child_process'); + const rgArgs = [ + '-l', + '--type-add', 'code:*.{ts,tsx,js,jsx,py,go,rs,java,c,h,cpp,cc,cxx,hpp,hxx,hh,cs,php,swift}', + '-t', 'code', + `\\b${oldName}\\b`, + '.', + ]; + const output = execFileSync('rg', rgArgs, { cwd: repo.repoPath, encoding: 'utf-8', timeout: 5000 }); const files = output.trim().split('\n').filter(f => f.length > 0); for (const file of files) { @@ -1234,19 +1277,20 @@ export class LocalBackend { if (graphFiles.has(normalizedFile)) continue; // already covered by graph try { - const content = await fs.readFile(path.join(repo.repoPath, normalizedFile), 'utf-8'); + const content = await fs.readFile(assertSafePath(normalizedFile), 'utf-8'); const lines = content.split('\n'); const regex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g'); for (let i = 0; i < lines.length; i++) { + regex.lastIndex = 0; if (regex.test(lines[i])) { + regex.lastIndex = 0; addEdit(normalizedFile, i + 1, lines[i].trim(), lines[i].replace(regex, new_name).trim(), 'text_search'); astSearchEdits++; - regex.lastIndex = 0; // reset regex } } - } catch { /* skip */ } + } catch (e) { logQueryError('rename:text-search-read', e); } } - } catch { /* rg not available or no additional matches */ } + } catch (e) { logQueryError('rename:ripgrep', e); } // Step 4: Apply or preview const allChanges = Array.from(changes.values()); @@ -1256,12 +1300,12 @@ export class LocalBackend { // Apply edits to files for (const change of allChanges) { try { - const fullPath = path.join(repo.repoPath, change.file_path); + const fullPath = assertSafePath(change.file_path); let content = await fs.readFile(fullPath, 'utf-8'); const regex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g'); content = content.replace(regex, new_name); await fs.writeFile(fullPath, content, 'utf-8'); - } catch { /* skip failed files */ } + } catch (e) { logQueryError('rename:apply-edit', e); } } } @@ -1285,27 +1329,50 @@ export class LocalBackend { relationTypes?: string[]; includeTests?: boolean; minConfidence?: number; + }): Promise<any> { + try { + return await this._impactImpl(repo, params); + } catch (err: any) { + // Return structured error instead of crashing (#321) + return { + error: (err instanceof Error ? err.message : String(err)) || 'Impact analysis failed', + target: { name: params.target }, + direction: params.direction, + impactedCount: 0, + risk: 'UNKNOWN', + suggestion: 'The graph query failed — try gitnexus context <symbol> as a fallback', + }; + } + } + + private async _impactImpl(repo: RepoHandle, params: { + target: string; + direction: 'upstream' | 'downstream'; + maxDepth?: number; + relationTypes?: string[]; + includeTests?: boolean; + minConfidence?: number; }): Promise<any> { await this.ensureInitialized(repo.id); const { target, direction } = params; const maxDepth = params.maxDepth || 3; - const relationTypes = params.relationTypes && params.relationTypes.length > 0 - ? params.relationTypes + const rawRelTypes = params.relationTypes && params.relationTypes.length > 0 + ? params.relationTypes.filter(t => VALID_RELATION_TYPES.has(t)) : ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS']; + const relationTypes = rawRelTypes.length > 0 ? rawRelTypes : ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS']; const includeTests = params.includeTests ?? false; const minConfidence = params.minConfidence ?? 0; - + const relTypeFilter = relationTypes.map(t => `'${t}'`).join(', '); const confidenceFilter = minConfidence > 0 ? ` AND r.confidence >= ${minConfidence}` : ''; - - const targetQuery = ` + + const targets = await executeParameterized(repo.id, ` MATCH (n) - WHERE n.name = '${target.replace(/'/g, "''")}' + WHERE n.name = $targetName RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath LIMIT 1 - `; - const targets = await executeQuery(repo.id, targetQuery); + `, { targetName: target }); if (targets.length === 0) return { error: `Target '${target}' not found` }; const sym = targets[0]; @@ -1314,6 +1381,7 @@ export class LocalBackend { const impacted: any[] = []; const visited = new Set<string>([symId]); let frontier = [symId]; + let traversalComplete = true; for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) { const nextFrontier: string[] = []; @@ -1347,7 +1415,13 @@ export class LocalBackend { }); } } - } catch { /* query failed for this depth level */ } + } catch (e) { + logQueryError('impact:depth-traversal', e); + // Break out of depth loop on query failure but return partial results + // collected so far, rather than silently swallowing the error (#321) + traversalComplete = false; + break; + } frontier = nextFrontier; } @@ -1430,6 +1504,7 @@ export class LocalBackend { direction, impactedCount: impacted.length, risk, + ...(!traversalComplete && { partial: true }), summary: { direct: directCount, processes_affected: processCount, @@ -1509,13 +1584,11 @@ export class LocalBackend { const repo = await this.resolveRepo(repoName); await this.ensureInitialized(repo.id); - const escaped = name.replace(/'/g, "''"); - const clusterQuery = ` + const clusters = await executeParameterized(repo.id, ` MATCH (c:Community) - WHERE c.label = '${escaped}' OR c.heuristicLabel = '${escaped}' + WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName RETURN c.id AS id, c.label AS label, c.heuristicLabel AS heuristicLabel, c.cohesion AS cohesion, c.symbolCount AS symbolCount - `; - const clusters = await executeQuery(repo.id, clusterQuery); + `, { clusterName: name }); if (clusters.length === 0) return { error: `Cluster '${name}' not found` }; const rawClusters = clusters.map((c: any) => ({ @@ -1530,12 +1603,12 @@ export class LocalBackend { weightedCohesion += (c.cohesion || 0) * s; } - const members = await executeQuery(repo.id, ` + const members = await executeParameterized(repo.id, ` MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) - WHERE c.label = '${escaped}' OR c.heuristicLabel = '${escaped}' + WHERE c.label = $clusterName OR c.heuristicLabel = $clusterName RETURN DISTINCT n.name AS name, labels(n)[0] AS type, n.filePath AS filePath LIMIT 30 - `); + `, { clusterName: name }); return { cluster: { @@ -1560,22 +1633,21 @@ export class LocalBackend { const repo = await this.resolveRepo(repoName); await this.ensureInitialized(repo.id); - const escaped = name.replace(/'/g, "''"); - const processes = await executeQuery(repo.id, ` + const processes = await executeParameterized(repo.id, ` MATCH (p:Process) - WHERE p.label = '${escaped}' OR p.heuristicLabel = '${escaped}' + WHERE p.label = $processName OR p.heuristicLabel = $processName RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount LIMIT 1 - `); + `, { processName: name }); if (processes.length === 0) return { error: `Process '${name}' not found` }; const proc = processes[0]; const procId = proc.id || proc[0]; - const steps = await executeQuery(repo.id, ` - MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: '${procId}'}) + const steps = await executeParameterized(repo.id, ` + MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: $procId}) RETURN n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, r.step AS step ORDER BY r.step - `); + `, { procId }); return { process: { @@ -1589,8 +1661,12 @@ export class LocalBackend { } async disconnect(): Promise<void> { - await closeKuzu(); // close all connections - await disposeEmbedder(); + await closeLbug(); // close all connections + // Note: we intentionally do NOT call disposeEmbedder() here. + // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs, + // and importing the embedder module on Node v24+ crashes if onnxruntime + // was never loaded during the session. Since process.exit(0) follows + // immediately after disconnect(), the OS reclaims everything. See #38, #89. this.repos.clear(); this.contextCache.clear(); this.initializedRepos.clear(); diff --git a/gitnexus/src/mcp/resources.ts b/gitnexus/src/mcp/resources.ts index 95c7884dc4..d6e5a512b7 100644 --- a/gitnexus/src/mcp/resources.ts +++ b/gitnexus/src/mcp/resources.ts @@ -328,6 +328,10 @@ relationships: - IMPORTS: Module imports - EXTENDS: Class inheritance - IMPLEMENTS: Interface implementation + - HAS_METHOD: Class/Struct/Interface owns a Method + - HAS_PROPERTY: Class/Struct/Interface owns a Property (field) + - ACCESSES: Function/Method reads or writes a Property (reason: 'read' or 'write') + - OVERRIDES: Method overrides another Method (MRO) - MEMBER_OF: Symbol belongs to community - STEP_IN_PROCESS: Symbol is step N in process diff --git a/gitnexus/src/mcp/server.ts b/gitnexus/src/mcp/server.ts index 5775856241..2b7314905d 100644 --- a/gitnexus/src/mcp/server.ts +++ b/gitnexus/src/mcp/server.ts @@ -1,18 +1,19 @@ /** * MCP Server (Multi-Repo) - * + * * Model Context Protocol server that runs on stdio. * External AI tools (Cursor, Claude) spawn this process and * communicate via stdin/stdout using the MCP protocol. - * + * * Supports multiple indexed repositories via the global registry. - * + * * Tools: list_repos, query, cypher, context, impact, detect_changes, rename * Resources: repos, repo/{name}/context, repo/{name}/clusters, ... */ +import { createRequire } from 'module'; import { Server } from '@modelcontextprotocol/sdk/server/index.js'; -import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'; +import { CompatibleStdioServerTransport } from './compatible-stdio-transport.js'; import { CallToolRequestSchema, ListToolsRequestSchema, @@ -23,15 +24,16 @@ import { GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js'; import { GITNEXUS_TOOLS } from './tools.js'; +import { realStdoutWrite } from './core/lbug-adapter.js'; import type { LocalBackend } from './local/local-backend.js'; import { getResourceDefinitions, getResourceTemplates, readResource } from './resources.js'; /** * Next-step hints appended to tool responses. - * + * * Agents often stop after one tool call. These hints guide them to the * logical next action, creating a self-guiding workflow without hooks. - * + * * Design: Each hint is a short, actionable instruction (not a suggestion). * The hint references the specific tool/resource to use next. */ @@ -75,11 +77,17 @@ function getNextStepHint(toolName: string, args: Record<string, any> | undefined } } -export async function startMCPServer(backend: LocalBackend): Promise<void> { +/** + * Create a configured MCP Server with all handlers registered. + * Transport-agnostic — caller connects the desired transport. + */ +export function createMCPServer(backend: LocalBackend): Server { + const require = createRequire(import.meta.url); + const pkgVersion: string = require('../../package.json').version; const server = new Server( { name: 'gitnexus', - version: '1.1.9', + version: pkgVersion, }, { capabilities: { @@ -119,7 +127,7 @@ export async function startMCPServer(backend: LocalBackend): Promise<void> { // Handle read resource request server.setRequestHandler(ReadResourceRequestSchema, async (request) => { const { uri } = request.params; - + try { const content = await readResource(uri, backend); return { @@ -209,7 +217,7 @@ export async function startMCPServer(backend: LocalBackend): Promise<void> { // Handle get prompt request server.setRequestHandler(GetPromptRequestSchema, async (request) => { const { name, arguments: args } = request.params; - + if (name === 'detect_impact') { const scope = args?.scope || 'all'; const baseRef = args?.base_ref || ''; @@ -233,7 +241,7 @@ Present the analysis as a clear risk report.`, ], }; } - + if (name === 'generate_map') { const repo = args?.repo || ''; return { @@ -247,7 +255,7 @@ Present the analysis as a clear risk report.`, Follow these steps: 1. READ \`gitnexus://repo/${repo || '{name}'}/context\` for codebase stats 2. READ \`gitnexus://repo/${repo || '{name}'}/clusters\` to see all functional areas -3. READ \`gitnexus://repo/${repo || '{name}'}/processes\` to see all execution flows +3. READ \`gitnexus://repo/${repo || '{name}'}/processes\` to see all execution flows 4. For the top 5 most important processes, READ \`gitnexus://repo/${repo || '{name}'}/process/{name}\` for step-by-step traces 5. Generate a mermaid architecture diagram showing the major areas and their connections 6. Write an ARCHITECTURE.md file with: overview, functional areas, key execution flows, and the mermaid diagram`, @@ -256,24 +264,60 @@ Follow these steps: ], }; } - + throw new Error(`Unknown prompt: ${name}`); }); - // Connect to stdio transport - const transport = new StdioServerTransport(); + return server; +} + +/** + * Start the MCP server on stdio transport (for CLI use). + */ +export async function startMCPServer(backend: LocalBackend): Promise<void> { + const server = createMCPServer(backend); + + // Use the shared stdout reference captured at module-load time by the + // lbug-adapter. Avoids divergence if anything patches stdout between + // module load and server start. + const _safeStdout = new Proxy(process.stdout, { + get(target, prop, receiver) { + if (prop === 'write') return realStdoutWrite; + const val = Reflect.get(target, prop, receiver); + return typeof val === 'function' ? val.bind(target) : val; + } + }); + const transport = new CompatibleStdioServerTransport(process.stdin, _safeStdout); await server.connect(transport); + // Graceful shutdown helper + let shuttingDown = false; + const shutdown = async (exitCode = 0) => { + if (shuttingDown) return; + shuttingDown = true; + try { await backend.disconnect(); } catch {} + try { await server.close(); } catch {} + process.exit(exitCode); + }; + // Handle graceful shutdown - process.on('SIGINT', async () => { - await backend.disconnect(); - await server.close(); - process.exit(0); + process.on('SIGINT', shutdown); + process.on('SIGTERM', shutdown); + + // Log crashes to stderr so they aren't silently lost. + // uncaughtException is fatal — shut down. + // unhandledRejection is logged but kept non-fatal (availability-first): + // killing the server for one missed catch would be worse than logging it. + process.on('uncaughtException', (err) => { + process.stderr.write(`GitNexus MCP uncaughtException: ${err?.stack || err}\n`); + shutdown(1); + }); + process.on('unhandledRejection', (reason: any) => { + process.stderr.write(`GitNexus MCP unhandledRejection: ${reason?.stack || reason}\n`); }); - process.on('SIGTERM', async () => { - await backend.disconnect(); - await server.close(); - process.exit(0); - }); + // Handle stdio errors — stdin close means the parent process is gone + process.stdin.on('end', shutdown); + process.stdin.on('error', () => shutdown()); + process.stdout.on('error', () => shutdown()); } diff --git a/gitnexus/src/mcp/staleness.ts b/gitnexus/src/mcp/staleness.ts index 0b7cf2a15e..8c044e61dd 100644 --- a/gitnexus/src/mcp/staleness.ts +++ b/gitnexus/src/mcp/staleness.ts @@ -5,7 +5,7 @@ * Returns a hint for the LLM to call analyze if stale. */ -import { execSync } from 'child_process'; +import { execFileSync } from 'child_process'; import path from 'path'; export interface StalenessInfo { @@ -20,8 +20,8 @@ export interface StalenessInfo { export function checkStaleness(repoPath: string, lastCommit: string): StalenessInfo { try { // Get count of commits between lastCommit and HEAD - const result = execSync( - `git rev-list --count ${lastCommit}..HEAD`, + const result = execFileSync( + 'git', ['rev-list', '--count', `${lastCommit}..HEAD`], { cwd: repoPath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] } ).trim(); diff --git a/gitnexus/src/mcp/tools.ts b/gitnexus/src/mcp/tools.ts index 9e2fe7eed4..a8e5ce8acb 100644 --- a/gitnexus/src/mcp/tools.ts +++ b/gitnexus/src/mcp/tools.ts @@ -78,7 +78,7 @@ SCHEMA: - Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process - Multi-language nodes (use backticks): \`Struct\`, \`Enum\`, \`Trait\`, \`Impl\`, etc. - All edges via single CodeRelation table with 'type' property -- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, MEMBER_OF, STEP_IN_PROCESS +- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, ACCESSES, OVERRIDES, MEMBER_OF, STEP_IN_PROCESS - Edge properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32) EXAMPLES: @@ -91,6 +91,21 @@ EXAMPLES: • Trace a process: MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) WHERE p.heuristicLabel = "UserLogin" RETURN s.name, r.step ORDER BY r.step +• Find all methods of a class: + MATCH (c:Class {name: "UserService"})-[r:CodeRelation {type: 'HAS_METHOD'}]->(m:Method) RETURN m.name, m.parameterCount, m.returnType + +• Find all properties of a class: + MATCH (c:Class {name: "User"})-[r:CodeRelation {type: 'HAS_PROPERTY'}]->(p:Property) RETURN p.name, p.description + +• Find all writers of a field: + MATCH (f:Function)-[r:CodeRelation {type: 'ACCESSES', reason: 'write'}]->(p:Property) WHERE p.name = "address" RETURN f.name, f.filePath + +• Find method overrides (MRO resolution): + MATCH (winner:Method)-[r:CodeRelation {type: 'OVERRIDES'}]->(loser:Method) RETURN winner.name, winner.filePath, loser.filePath, r.reason + +• Detect diamond inheritance: + MATCH (d:Class)-[:CodeRelation {type: 'EXTENDS'}]->(b1), (d)-[:CodeRelation {type: 'EXTENDS'}]->(b2), (b1)-[:CodeRelation {type: 'EXTENDS'}]->(a), (b2)-[:CodeRelation {type: 'EXTENDS'}]->(a) WHERE b1 <> b2 RETURN d.name, b1.name, b2.name, a.name + OUTPUT: Returns { markdown, row_count } — results formatted as a Markdown table for easy reading. TIPS: @@ -110,12 +125,14 @@ TIPS: { name: 'context', description: `360-degree view of a single code symbol. -Shows categorized incoming/outgoing references (calls, imports, extends, implements), process participation, and file location. +Shows categorized incoming/outgoing references (calls, imports, extends, implements, methods, properties, overrides), process participation, and file location. WHEN TO USE: After query() to understand a specific symbol in depth. When you need to know all callers, callees, and what execution flows a symbol participates in. AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/process/{processName} for full execution trace. -Handles disambiguation: if multiple symbols share the same name, returns candidates for you to pick from. Use uid param for zero-ambiguity lookup from prior results.`, +Handles disambiguation: if multiple symbols share the same name, returns candidates for you to pick from. Use uid param for zero-ambiguity lookup from prior results. + +NOTE: ACCESSES edges (field read/write tracking) are included in context results. Coverage: reads detected during call chain resolution (e.g., user.address.save() emits a read on 'address'). Standalone reads and writes require Phase 2.`, inputSchema: { type: 'object', properties: { @@ -191,7 +208,9 @@ Depth groups: - d=2: LIKELY AFFECTED (indirect) - d=3: MAY NEED TESTING (transitive) -EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS +TIP: Default traversal uses CALLS/IMPORTS/EXTENDS/IMPLEMENTS. For class members, include HAS_METHOD and HAS_PROPERTY in relationTypes. For field access analysis, include ACCESSES in relationTypes. + +EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, OVERRIDES, ACCESSES Confidence: 1.0 = certain, <0.8 = fuzzy match`, inputSchema: { type: 'object', @@ -199,7 +218,7 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`, target: { type: 'string', description: 'Name of function, class, or file to analyze' }, direction: { type: 'string', description: 'upstream (what depends on this) or downstream (what this depends on)' }, maxDepth: { type: 'number', description: 'Max relationship depth (default: 3)', default: 3 }, - relationTypes: { type: 'array', items: { type: 'string' }, description: 'Filter: CALLS, IMPORTS, EXTENDS, IMPLEMENTS (default: usage-based)' }, + relationTypes: { type: 'array', items: { type: 'string' }, description: 'Filter: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, OVERRIDES, ACCESSES (default: usage-based, ACCESSES excluded by default)' }, includeTests: { type: 'boolean', description: 'Include test files (default: false)' }, minConfidence: { type: 'number', description: 'Minimum confidence 0-1 (default: 0.7)' }, repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' }, diff --git a/gitnexus/src/server/api.ts b/gitnexus/src/server/api.ts index eb690a4d92..c55519b3d0 100644 --- a/gitnexus/src/server/api.ts +++ b/gitnexus/src/server/api.ts @@ -1,29 +1,30 @@ /** - * HTTP API Server (Multi-Repo) + * HTTP API Server * - * REST API for browser-based clients to query indexed repositories. - * Uses LocalBackend for multi-repo support via the global registry — - * the same backend the MCP server uses. + * REST API for browser-based clients to query the local .gitnexus/ index. + * Also hosts the MCP server over StreamableHTTP for remote AI tool access. + * + * Security: binds to 127.0.0.1 by default (use --host to override). + * CORS is restricted to localhost and the deployed site. */ import express from 'express'; import cors from 'cors'; import path from 'path'; import fs from 'fs/promises'; -import { LocalBackend } from '../mcp/local/local-backend.js'; -import { NODE_TABLES } from '../core/kuzu/schema.js'; +import { loadMeta, listRegisteredRepos } from '../storage/repo-manager.js'; +import { executeQuery, closeLbug, withLbugDb } from '../core/lbug/lbug-adapter.js'; +import { NODE_TABLES } from '../core/lbug/schema.js'; import { GraphNode, GraphRelationship } from '../core/graph/types.js'; +import { searchFTSFromLbug } from '../core/search/bm25-index.js'; +import { hybridSearch } from '../core/search/hybrid-search.js'; +// Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node +// at server startup — crashes on unsupported Node ABI versions (#89) +import { LocalBackend } from '../mcp/local/local-backend.js'; +import { mountMCPEndpoints } from './mcp-http.js'; -/** - * Build the full knowledge graph for a repo by querying each node table - * and all relationships via the backend's cypher tool. - */ -const buildGraph = async ( - backend: LocalBackend, - repoName: string, -): Promise<{ nodes: GraphNode[]; relationships: GraphRelationship[] }> => { +const buildGraph = async (): Promise<{ nodes: GraphNode[]; relationships: GraphRelationship[] }> => { const nodes: GraphNode[] = []; - for (const table of NODE_TABLES) { try { let query = ''; @@ -39,10 +40,7 @@ const buildGraph = async ( query = `MATCH (n:${table}) RETURN n.id AS id, n.name AS name, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine, n.content AS content`; } - const result = await backend.executeCypher(repoName, query); - // cypher returns the rows directly (array), or { error } on failure - const rows = Array.isArray(result) ? result : []; - + const rows = await executeQuery(query); for (const row of rows) { nodes.push({ id: row.id ?? row[0], @@ -70,53 +68,49 @@ const buildGraph = async ( } const relationships: GraphRelationship[] = []; - try { - const relResult = await backend.executeCypher( - repoName, - `MATCH (a)-[r:CodeRelation]->(b) RETURN a.id AS sourceId, b.id AS targetId, r.type AS type, r.confidence AS confidence, r.reason AS reason, r.step AS step`, - ); - const relRows = Array.isArray(relResult) ? relResult : []; - - for (const row of relRows) { - relationships.push({ - id: `${row.sourceId}_${row.type}_${row.targetId}`, - type: row.type, - sourceId: row.sourceId, - targetId: row.targetId, - confidence: row.confidence, - reason: row.reason, - step: row.step, - }); - } - } catch (err: any) { - console.warn('GitNexus: relationship query failed:', err?.message); + const relRows = await executeQuery( + `MATCH (a)-[r:CodeRelation]->(b) RETURN a.id AS sourceId, b.id AS targetId, r.type AS type, r.confidence AS confidence, r.reason AS reason, r.step AS step` + ); + for (const row of relRows) { + relationships.push({ + id: `${row.sourceId}_${row.type}_${row.targetId}`, + type: row.type, + sourceId: row.sourceId, + targetId: row.targetId, + confidence: row.confidence, + reason: row.reason, + step: row.step, + }); } return { nodes, relationships }; }; -const httpStatus = (err: any): number => { - const msg = err?.message ?? ''; - if (msg.includes('not found') || msg.includes('No indexed')) return 404; +const statusFromError = (err: any): number => { + const msg = String(err?.message ?? ''); + if (msg.includes('No indexed repositories') || msg.includes('not found')) return 404; if (msg.includes('Multiple repositories')) return 400; return 500; }; -export const createServer = async (port: number) => { - const backend = new LocalBackend(); - const hasRepos = await backend.init(); +const requestedRepo = (req: express.Request): string | undefined => { + const fromQuery = typeof req.query.repo === 'string' ? req.query.repo : undefined; + if (fromQuery) return fromQuery; - if (!hasRepos) { - console.warn('GitNexus: No indexed repositories found. The server will start but most endpoints will return errors.'); - console.warn('Run "gitnexus analyze" in a repository to index it first.'); + if (req.body && typeof req.body === 'object' && typeof req.body.repo === 'string') { + return req.body.repo; } + return undefined; +}; + +export const createServer = async (port: number, host: string = '127.0.0.1') => { const app = express(); + + // CORS: only allow localhost origins and the deployed site. + // Non-browser requests (curl, server-to-server) have no origin and are allowed. app.use(cors({ origin: (origin, callback) => { - // Allow requests with no origin (curl, server-to-server), localhost, and the deployed site. - // The server binds to 127.0.0.1 so only the local machine can reach it — CORS just gates - // which browser-tab origins may issue the request. if ( !origin || origin.startsWith('http://localhost:') @@ -131,123 +125,144 @@ export const createServer = async (port: number) => { })); app.use(express.json({ limit: '10mb' })); - // ─── GET /api/repos ───────────────────────────────────────────── - // List all indexed repositories + // Initialize MCP backend (multi-repo, shared across all MCP sessions) + const backend = new LocalBackend(); + await backend.init(); + const cleanupMcp = mountMCPEndpoints(app, backend); + + // Helper: resolve a repo by name from the global registry, or default to first + const resolveRepo = async (repoName?: string) => { + const repos = await listRegisteredRepos(); + if (repos.length === 0) return null; + if (repoName) return repos.find(r => r.name === repoName) || null; + return repos[0]; // default to first + }; + + // List all registered repos app.get('/api/repos', async (_req, res) => { try { - const repos = await backend.listRepos(); - res.json(repos); + const repos = await listRegisteredRepos(); + res.json(repos.map(r => ({ + name: r.name, path: r.path, indexedAt: r.indexedAt, + lastCommit: r.lastCommit, stats: r.stats, + }))); } catch (err: any) { res.status(500).json({ error: err.message || 'Failed to list repos' }); } }); - // ─── GET /api/repo?repo=X ────────────────────────────────────── - // Get metadata for a specific repo + // Get repo info app.get('/api/repo', async (req, res) => { try { - const repoName = req.query.repo as string | undefined; - const repo = await backend.resolveRepo(repoName); + const entry = await resolveRepo(requestedRepo(req)); + if (!entry) { + res.status(404).json({ error: 'Repository not found. Run: gitnexus analyze' }); + return; + } + const meta = await loadMeta(entry.storagePath); res.json({ - name: repo.name, - path: repo.repoPath, - indexedAt: repo.indexedAt, - lastCommit: repo.lastCommit, - stats: repo.stats || {}, + name: entry.name, + repoPath: entry.path, + indexedAt: meta?.indexedAt ?? entry.indexedAt, + stats: meta?.stats ?? entry.stats ?? {}, }); } catch (err: any) { - res.status(httpStatus(err)) - .json({ error: err.message || 'Repository not found' }); + res.status(500).json({ error: err.message || 'Failed to get repo info' }); } }); - // ─── GET /api/graph?repo=X ───────────────────────────────────── - // Full knowledge graph (all nodes + relationships) + // Get full graph app.get('/api/graph', async (req, res) => { try { - const repoName = req.query.repo as string | undefined; - // Resolve repo to validate it exists and get the name - const repo = await backend.resolveRepo(repoName); - const graph = await buildGraph(backend, repo.name); + const entry = await resolveRepo(requestedRepo(req)); + if (!entry) { + res.status(404).json({ error: 'Repository not found' }); + return; + } + const lbugPath = path.join(entry.storagePath, 'lbug'); + const graph = await withLbugDb(lbugPath, async () => buildGraph()); res.json(graph); } catch (err: any) { - res.status(httpStatus(err)) - .json({ error: err.message || 'Failed to build graph' }); + res.status(500).json({ error: err.message || 'Failed to build graph' }); } }); - // ─── POST /api/query ─────────────────────────────────────────── - // Execute a raw Cypher query. - // This endpoint is intentionally unrestricted (no query validation) because - // the server binds to 127.0.0.1 only — it exposes full graph query - // capabilities to local clients by design. + // Execute Cypher query app.post('/api/query', async (req, res) => { try { - const repoName = (req.body.repo ?? req.query.repo) as string | undefined; const cypher = req.body.cypher as string; - if (!cypher) { res.status(400).json({ error: 'Missing "cypher" in request body' }); return; } - const result = await backend.executeCypher(repoName, cypher); - if (result && !Array.isArray(result) && (result as any).error) { - res.status(500).json({ error: (result as any).error }); + const entry = await resolveRepo(requestedRepo(req)); + if (!entry) { + res.status(404).json({ error: 'Repository not found' }); return; } + const lbugPath = path.join(entry.storagePath, 'lbug'); + const result = await withLbugDb(lbugPath, () => executeQuery(cypher)); res.json({ result }); } catch (err: any) { - res.status(httpStatus(err)) - .json({ error: err.message || 'Query failed' }); + res.status(500).json({ error: err.message || 'Query failed' }); } }); - // ─── POST /api/search ────────────────────────────────────────── - // Process-grouped semantic search + // Search app.post('/api/search', async (req, res) => { try { - const repoName = (req.body.repo ?? req.query.repo) as string | undefined; const query = (req.body.query ?? '').trim(); - const limit = req.body.limit as number | undefined; - if (!query) { res.status(400).json({ error: 'Missing "query" in request body' }); return; } - const results = await backend.callTool('query', { - repo: repoName, - query, - limit, + const entry = await resolveRepo(requestedRepo(req)); + if (!entry) { + res.status(404).json({ error: 'Repository not found' }); + return; + } + const lbugPath = path.join(entry.storagePath, 'lbug'); + const parsedLimit = Number(req.body.limit ?? 10); + const limit = Number.isFinite(parsedLimit) + ? Math.max(1, Math.min(100, Math.trunc(parsedLimit))) + : 10; + + const results = await withLbugDb(lbugPath, async () => { + const { isEmbedderReady } = await import('../core/embeddings/embedder.js'); + if (isEmbedderReady()) { + const { semanticSearch } = await import('../core/embeddings/embedding-pipeline.js'); + return hybridSearch(query, limit, executeQuery, semanticSearch); + } + // FTS-only fallback when embeddings aren't loaded + return searchFTSFromLbug(query, limit); }); res.json({ results }); } catch (err: any) { - res.status(httpStatus(err)) - .json({ error: err.message || 'Search failed' }); + res.status(500).json({ error: err.message || 'Search failed' }); } }); - // ─── GET /api/file?repo=X&path=Y ────────────────────────────── - // Read a file from a resolved repo path on disk + // Read file — with path traversal guard app.get('/api/file', async (req, res) => { try { - const repoName = req.query.repo as string | undefined; + const entry = await resolveRepo(requestedRepo(req)); + if (!entry) { + res.status(404).json({ error: 'Repository not found' }); + return; + } const filePath = req.query.path as string; - if (!filePath) { - res.status(400).json({ error: 'Missing "path" query parameter' }); + res.status(400).json({ error: 'Missing path' }); return; } - const repo = await backend.resolveRepo(repoName); - - // Resolve the full path and validate it stays within the repo root - const repoRoot = path.resolve(repo.repoPath); + // Prevent path traversal — resolve and verify the path stays within the repo root + const repoRoot = path.resolve(entry.path); const fullPath = path.resolve(repoRoot, filePath); - if (!fullPath.startsWith(repoRoot + path.sep) && fullPath !== repoRoot) { - res.status(403).json({ error: 'Path traversal denied: path escapes repo root' }); + res.status(403).json({ error: 'Path traversal denied' }); return; } @@ -257,93 +272,86 @@ export const createServer = async (port: number) => { if (err.code === 'ENOENT') { res.status(404).json({ error: 'File not found' }); } else { - res.status(httpStatus(err)) - .json({ error: err.message || 'Failed to read file' }); + res.status(500).json({ error: err.message || 'Failed to read file' }); } } }); - // ─── GET /api/processes?repo=X ───────────────────────────────── - // List all processes for a repo + // List all processes app.get('/api/processes', async (req, res) => { try { - const repoName = req.query.repo as string | undefined; - const result = await backend.queryProcesses(repoName); + const result = await backend.queryProcesses(requestedRepo(req)); res.json(result); } catch (err: any) { - res.status(httpStatus(err)) - .json({ error: err.message || 'Failed to query processes' }); + res.status(statusFromError(err)).json({ error: err.message || 'Failed to query processes' }); } }); - // ─── GET /api/process?repo=X&name=Y ─────────────────────────── - // Get detailed process info including steps + // Process detail app.get('/api/process', async (req, res) => { try { - const repoName = req.query.repo as string | undefined; - const name = req.query.name as string; - + const name = String(req.query.name ?? '').trim(); if (!name) { res.status(400).json({ error: 'Missing "name" query parameter' }); return; } - const result = await backend.queryProcessDetail(name, repoName); - if (result.error) { + const result = await backend.queryProcessDetail(name, requestedRepo(req)); + if (result?.error) { res.status(404).json({ error: result.error }); return; } res.json(result); } catch (err: any) { - res.status(httpStatus(err)) - .json({ error: err.message || 'Failed to query process detail' }); + res.status(statusFromError(err)).json({ error: err.message || 'Failed to query process detail' }); } }); - // ─── GET /api/clusters?repo=X ───────────────────────────────── - // List all clusters for a repo + // List all clusters app.get('/api/clusters', async (req, res) => { try { - const repoName = req.query.repo as string | undefined; - const result = await backend.queryClusters(repoName); + const result = await backend.queryClusters(requestedRepo(req)); res.json(result); } catch (err: any) { - res.status(httpStatus(err)) - .json({ error: err.message || 'Failed to query clusters' }); + res.status(statusFromError(err)).json({ error: err.message || 'Failed to query clusters' }); } }); - // ─── GET /api/cluster?repo=X&name=Y ─────────────────────────── - // Get detailed cluster info including members + // Cluster detail app.get('/api/cluster', async (req, res) => { try { - const repoName = req.query.repo as string | undefined; - const name = req.query.name as string; - + const name = String(req.query.name ?? '').trim(); if (!name) { res.status(400).json({ error: 'Missing "name" query parameter' }); return; } - const result = await backend.queryClusterDetail(name, repoName); - if (result.error) { + const result = await backend.queryClusterDetail(name, requestedRepo(req)); + if (result?.error) { res.status(404).json({ error: result.error }); return; } res.json(result); } catch (err: any) { - res.status(httpStatus(err)) - .json({ error: err.message || 'Failed to query cluster detail' }); + res.status(statusFromError(err)).json({ error: err.message || 'Failed to query cluster detail' }); } }); - const server = app.listen(port, '127.0.0.1', () => { - console.log(`GitNexus server running on http://localhost:${port}`); - console.log(`Serving ${hasRepos ? 'all indexed repositories' : 'no repositories (run gitnexus analyze first)'}`); + // Global error handler — catch anything the route handlers miss + app.use((err: any, _req: express.Request, res: express.Response, _next: express.NextFunction) => { + console.error('Unhandled error:', err); + res.status(500).json({ error: 'Internal server error' }); }); + const server = app.listen(port, host, () => { + console.log(`GitNexus server running on http://${host}:${port}`); + }); + + // Graceful shutdown — close Express + LadybugDB cleanly const shutdown = async () => { server.close(); + await cleanupMcp(); + await closeLbug(); await backend.disconnect(); process.exit(0); }; diff --git a/gitnexus/src/server/mcp-http.ts b/gitnexus/src/server/mcp-http.ts new file mode 100644 index 0000000000..acf85d53b8 --- /dev/null +++ b/gitnexus/src/server/mcp-http.ts @@ -0,0 +1,111 @@ +/** + * MCP over HTTP + * + * Mounts the GitNexus MCP server on Express using StreamableHTTP transport. + * Each connecting client gets its own stateful session; the LocalBackend + * is shared across all sessions (thread-safe — lazy LadybugDB per repo). + * + * Sessions are cleaned up on explicit close or after SESSION_TTL_MS of inactivity + * (guards against network drops that never trigger onclose). + */ + +import type { Express, Request, Response } from 'express'; +import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'; +import { Server } from '@modelcontextprotocol/sdk/server/index.js'; +import { createMCPServer } from '../mcp/server.js'; +import type { LocalBackend } from '../mcp/local/local-backend.js'; +import { randomUUID } from 'crypto'; + +interface MCPSession { + server: Server; + transport: StreamableHTTPServerTransport; + lastActivity: number; +} + +/** Idle sessions are evicted after 30 minutes */ +const SESSION_TTL_MS = 30 * 60 * 1000; +/** Cleanup sweep runs every 5 minutes */ +const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; + +export function mountMCPEndpoints(app: Express, backend: LocalBackend): () => Promise<void> { + const sessions = new Map<string, MCPSession>(); + + // Periodic cleanup of idle sessions (guards against network drops) + const cleanupTimer = setInterval(() => { + const now = Date.now(); + for (const [id, session] of sessions) { + if (now - session.lastActivity > SESSION_TTL_MS) { + try { session.server.close(); } catch {} + sessions.delete(id); + } + } + }, CLEANUP_INTERVAL_MS); + if (cleanupTimer && typeof cleanupTimer === 'object' && 'unref' in cleanupTimer) { + (cleanupTimer as NodeJS.Timeout).unref(); + } + + const handleMcpRequest = async (req: Request, res: Response) => { + const sessionId = req.headers['mcp-session-id'] as string | undefined; + + if (sessionId && sessions.has(sessionId)) { + // Existing session — delegate to its transport + const session = sessions.get(sessionId)!; + session.lastActivity = Date.now(); + await session.transport.handleRequest(req, res, req.body); + } else if (sessionId) { + // Unknown/expired session ID — tell client to re-initialize (per MCP spec) + res.status(404).json({ + jsonrpc: '2.0', + error: { code: -32001, message: 'Session not found. Re-initialize.' }, + id: null, + }); + } else if (req.method === 'POST') { + // No session ID — new client initializing + const transport = new StreamableHTTPServerTransport({ + sessionIdGenerator: () => randomUUID(), + }); + const server = createMCPServer(backend); + await server.connect(transport); + await transport.handleRequest(req, res, req.body); + + if (transport.sessionId) { + sessions.set(transport.sessionId, { server, transport, lastActivity: Date.now() }); + transport.onclose = () => { + sessions.delete(transport.sessionId!); + }; + } + } else { + res.status(400).json({ + jsonrpc: '2.0', + error: { code: -32000, message: 'No valid session. Send a POST to initialize.' }, + id: null, + }); + } + }; + + app.all('/api/mcp', (req: Request, res: Response) => { + void handleMcpRequest(req, res).catch((err: any) => { + console.error('MCP HTTP request failed:', err); + if (res.headersSent) return; + res.status(500).json({ + jsonrpc: '2.0', + error: { code: -32000, message: 'Internal MCP server error' }, + id: null, + }); + }); + }); + + const cleanup = async () => { + clearInterval(cleanupTimer); + const closers = [...sessions.values()].map(async session => { + try { + await Promise.resolve(session.server.close()); + } catch {} + }); + sessions.clear(); + await Promise.allSettled(closers); + }; + + console.log('MCP HTTP endpoints mounted at /api/mcp'); + return cleanup; +} diff --git a/gitnexus/src/storage/git.ts b/gitnexus/src/storage/git.ts index 95deca1109..99609ac1cb 100644 --- a/gitnexus/src/storage/git.ts +++ b/gitnexus/src/storage/git.ts @@ -1,4 +1,5 @@ import { execSync } from 'child_process'; +import path from 'path'; // Git utilities for repository detection, commit tracking, and diff analysis @@ -24,9 +25,11 @@ export const getCurrentCommit = (repoPath: string): string => { */ export const getGitRoot = (fromPath: string): string | null => { try { - return execSync('git rev-parse --show-toplevel', { cwd: fromPath }) + const raw = execSync('git rev-parse --show-toplevel', { cwd: fromPath }) .toString() .trim(); + // On Windows, git returns /d/Projects/Foo — path.resolve normalizes to D:\Projects\Foo + return path.resolve(raw); } catch { return null; } diff --git a/gitnexus/src/storage/repo-manager.ts b/gitnexus/src/storage/repo-manager.ts index 5ec4006be8..f6a74ff3bd 100644 --- a/gitnexus/src/storage/repo-manager.ts +++ b/gitnexus/src/storage/repo-manager.ts @@ -27,7 +27,7 @@ export interface RepoMeta { export interface IndexedRepo { repoPath: string; storagePath: string; - kuzuPath: string; + lbugPath: string; metaPath: string; meta: RepoMeta; } @@ -62,11 +62,60 @@ export const getStoragePaths = (repoPath: string) => { const storagePath = getStoragePath(repoPath); return { storagePath, - kuzuPath: path.join(storagePath, 'kuzu'), + lbugPath: path.join(storagePath, 'lbug'), metaPath: path.join(storagePath, 'meta.json'), }; }; +/** + * Check whether a KuzuDB index exists in the given storage path. + * Non-destructive — safe to call from status commands. + */ +export const hasKuzuIndex = async (storagePath: string): Promise<boolean> => { + try { + await fs.stat(path.join(storagePath, 'kuzu')); + return true; + } catch { + return false; + } +}; + +/** + * Clean up stale KuzuDB files after migration to LadybugDB. + * + * Returns: + * found — true if .gitnexus/kuzu existed and was deleted + * needsReindex — true if kuzu existed but lbug does not (re-analyze required) + * + * Callers own the user-facing messaging; this function only deletes files. + */ +export const cleanupOldKuzuFiles = async ( + storagePath: string, +): Promise<{ found: boolean; needsReindex: boolean }> => { + const oldPath = path.join(storagePath, 'kuzu'); + const newPath = path.join(storagePath, 'lbug'); + try { + await fs.stat(oldPath); + // Old kuzu file/dir exists — determine if lbug is already present + let needsReindex = false; + try { + await fs.stat(newPath); + } catch { + needsReindex = true; + } + // Delete kuzu database file and its sidecars (.wal, .lock) + for (const suffix of ['', '.wal', '.lock']) { + try { await fs.unlink(oldPath + suffix); } catch {} + } + // Also handle the case where kuzu was stored as a directory + try { await fs.rm(oldPath, { recursive: true, force: true }); } catch {} + return { found: true, needsReindex }; + } catch { + // Old path doesn't exist — nothing to do + return { found: false, needsReindex: false }; + } +}; + /** * Load metadata from an indexed repo */ @@ -201,9 +250,13 @@ export const registerRepo = async (repoPath: string, meta: RepoMeta): Promise<vo const { storagePath } = getStoragePaths(resolved); const entries = await readRegistry(); - const existing = entries.findIndex( - (e) => path.resolve(e.path) === resolved - ); + const existing = entries.findIndex((e) => { + const a = path.resolve(e.path); + const b = resolved; + return process.platform === 'win32' + ? a.toLowerCase() === b.toLowerCase() + : a === b; + }); const entry: RegistryEntry = { name, @@ -296,5 +349,10 @@ export const loadCLIConfig = async (): Promise<CLIConfig> => { export const saveCLIConfig = async (config: CLIConfig): Promise<void> => { const dir = getGlobalDir(); await fs.mkdir(dir, { recursive: true }); - await fs.writeFile(getGlobalConfigPath(), JSON.stringify(config, null, 2), 'utf-8'); + const configPath = getGlobalConfigPath(); + await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8'); + // Restrict file permissions on Unix (config may contain API keys) + if (process.platform !== 'win32') { + try { await fs.chmod(configPath, 0o600); } catch { /* best-effort */ } + } }; diff --git a/gitnexus/src/types/pipeline.ts b/gitnexus/src/types/pipeline.ts index c8848d562a..adcce64e97 100644 --- a/gitnexus/src/types/pipeline.ts +++ b/gitnexus/src/types/pipeline.ts @@ -19,7 +19,10 @@ export interface PipelineProgress { // Original result type (used internally in pipeline) export interface PipelineResult { graph: KnowledgeGraph; - fileContents: Map<string, string>; + /** Absolute path to the repo root — used for lazy file reads during LadybugDB loading */ + repoPath: string; + /** Total files scanned (for stats) */ + totalFileCount: number; communityResult?: CommunityDetectionResult; processResult?: ProcessDetectionResult; } @@ -29,14 +32,16 @@ export interface PipelineResult { export interface SerializablePipelineResult { nodes: GraphNode[]; relationships: GraphRelationship[]; - fileContents: Record<string, string>; // Object instead of Map + repoPath: string; + totalFileCount: number; } // Helper to convert PipelineResult to serializable format export const serializePipelineResult = (result: PipelineResult): SerializablePipelineResult => ({ - nodes: result.graph.nodes, - relationships: result.graph.relationships, - fileContents: Object.fromEntries(result.fileContents), + nodes: [...result.graph.iterNodes()], + relationships: [...result.graph.iterRelationships()], + repoPath: result.repoPath, + totalFileCount: result.totalFileCount, }); // Helper to reconstruct from serializable format (used in main thread) @@ -47,10 +52,11 @@ export const deserializePipelineResult = ( const graph = createGraph(); serialized.nodes.forEach(node => graph.addNode(node)); serialized.relationships.forEach(rel => graph.addRelationship(rel)); - + return { graph, - fileContents: new Map(Object.entries(serialized.fileContents)), + repoPath: serialized.repoPath, + totalFileCount: serialized.totalFileCount, }; }; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/handler_a.h b/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/handler_a.h new file mode 100644 index 0000000000..3ec03cd209 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/handler_a.h @@ -0,0 +1,6 @@ +#pragma once + +class Handler { +public: + void handle(); +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/handler_b.h b/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/handler_b.h new file mode 100644 index 0000000000..d8a81c3ea2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/handler_b.h @@ -0,0 +1,6 @@ +#pragma once + +class Handler { +public: + void process(); +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/processor.h b/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/processor.h new file mode 100644 index 0000000000..df7fab5e01 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-ambiguous/processor.h @@ -0,0 +1,8 @@ +#pragma once + +#include "handler_a.h" + +class Processor : public Handler { +public: + void run(); +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/models/Repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/models/Repo.h new file mode 100644 index 0000000000..5e9723b252 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/models/Repo.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class Repo { +public: + Repo(const std::string& name) : name_(name) {} + bool save() { return false; } +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/models/User.h b/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/models/User.h new file mode 100644 index 0000000000..44b48cd6d1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/models/User.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class User { +public: + User(const std::string& name) : name_(name) {} + bool save() { return true; } +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/services/App.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/services/App.cpp new file mode 100644 index 0000000000..c6e85f78c6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-assignment-chain/services/App.cpp @@ -0,0 +1,13 @@ +#include "models/User.h" +#include "models/Repo.h" + +// Tests C++ auto alias = u assignment chain propagation. +void processEntities() { + User u("alice"); + auto alias = u; + alias.save(); + + Repo r("maindb"); + auto rAlias = r; + rAlias.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/models/Repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/models/Repo.h new file mode 100644 index 0000000000..09e52e1f6c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/models/Repo.h @@ -0,0 +1,4 @@ +class Repo { +public: + void save() {} +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/models/User.h b/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/models/User.h new file mode 100644 index 0000000000..866e725667 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/models/User.h @@ -0,0 +1,4 @@ +class User { +public: + void save() {} +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/services/App.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/services/App.cpp new file mode 100644 index 0000000000..e09ec4a61c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-brace-init-inference/services/App.cpp @@ -0,0 +1,10 @@ +#include "../models/User.h" +#include "../models/Repo.h" + +void process() { + auto user = User{}; + user.save(); + + auto repo = Repo{}; + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-calls/main.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-calls/main.cpp new file mode 100644 index 0000000000..6d1a1f2190 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-calls/main.cpp @@ -0,0 +1,6 @@ +#include "one.h" +#include "zero.h" + +void run() { + write_audit("hello"); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-calls/one.h b/gitnexus/test/fixtures/lang-resolution/cpp-calls/one.h new file mode 100644 index 0000000000..30fdb0b7ad --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-calls/one.h @@ -0,0 +1,3 @@ +inline const char* write_audit(const char* message) { + return message; +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-calls/zero.h b/gitnexus/test/fixtures/lang-resolution/cpp-calls/zero.h new file mode 100644 index 0000000000..97e0c416e1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-calls/zero.h @@ -0,0 +1,3 @@ +inline const char* write_audit() { + return "zero"; +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/app.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/app.cpp new file mode 100644 index 0000000000..af1cd1bc3a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/app.cpp @@ -0,0 +1,8 @@ +#include "service.h" +#include "user.h" +#include "repo.h" + +void processUser() { + UserService svc; + svc.getUser().save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/repo.h new file mode 100644 index 0000000000..de47c01331 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/repo.h @@ -0,0 +1,6 @@ +#pragma once + +class Repo { +public: + bool save() { return true; } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/service.h b/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/service.h new file mode 100644 index 0000000000..342b2f63b8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/service.h @@ -0,0 +1,7 @@ +#pragma once +#include "user.h" + +class UserService { +public: + User getUser() { return User(); } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/user.h b/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/user.h new file mode 100644 index 0000000000..489f99f923 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-chain-call/user.h @@ -0,0 +1,6 @@ +#pragma once + +class User { +public: + bool save() { return true; } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-constructor-calls/app.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-calls/app.cpp new file mode 100644 index 0000000000..3cc0a5ad19 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-calls/app.cpp @@ -0,0 +1,6 @@ +#include "user.h" + +void processUser(const std::string& name) { + auto user = new User(name); + user->save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-constructor-calls/user.h b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-calls/user.h new file mode 100644 index 0000000000..44b48cd6d1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-calls/user.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class User { +public: + User(const std::string& name) : name_(name) {} + bool save() { return true; } +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/models/Repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/models/Repo.h new file mode 100644 index 0000000000..8e02df5058 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/models/Repo.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class Repo { +public: + Repo(const std::string& dbName) : dbName_(dbName) {} + bool save() { return false; } +private: + std::string dbName_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/models/User.h b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/models/User.h new file mode 100644 index 0000000000..44b48cd6d1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/models/User.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class User { +public: + User(const std::string& name) : name_(name) {} + bool save() { return true; } +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/services/App.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/services/App.cpp new file mode 100644 index 0000000000..ed954e03a1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-constructor-type-inference/services/App.cpp @@ -0,0 +1,9 @@ +#include "models/User.h" +#include "models/Repo.h" + +void processEntities() { + auto user = User("alice"); + auto repo = Repo("maindb"); + user.save(); + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-deep-field-chain/models.h b/gitnexus/test/fixtures/lang-resolution/cpp-deep-field-chain/models.h new file mode 100644 index 0000000000..6c0553b829 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-deep-field-chain/models.h @@ -0,0 +1,30 @@ +#pragma once + +class City { +public: + std::string zipCode; + + std::string getName() { + return "city"; + } +}; + +class Address { +public: + City city; + std::string street; + + void save() { + // persist address + } +}; + +class User { +public: + std::string name; + Address address; + + std::string greet() { + return name; + } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-deep-field-chain/service.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-deep-field-chain/service.cpp new file mode 100644 index 0000000000..bfa5a904c5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-deep-field-chain/service.cpp @@ -0,0 +1,9 @@ +#include "models.h" + +void processUser(User user) { + // 2-level chain: user.address → Address, then .save() → Address#save + user.address.save(); + + // 3-level chain: user.address → Address, .city → City, .getName() → City#getName + user.address.city.getName(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/App.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/App.cpp new file mode 100644 index 0000000000..849e5b2060 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/App.cpp @@ -0,0 +1,15 @@ +#include "User.h" +#include "Repo.h" +#include <vector> + +void processUsers(std::vector<User>* usersPtr) { + for (auto& user : *usersPtr) { + user.save(); + } +} + +void processRepos(std::vector<Repo>* reposPtr) { + for (const auto& repo : *reposPtr) { + repo.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/Repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/Repo.h new file mode 100644 index 0000000000..b3858517cb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/Repo.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class Repo { +public: + Repo(const std::string& name) : name_(name) {} + void save() {} +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/User.h b/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/User.h new file mode 100644 index 0000000000..fdb2273541 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-deref-range-for/User.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class User { +public: + User(const std::string& name) : name_(name) {} + void save() {} +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-diamond/animal.h b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/animal.h new file mode 100644 index 0000000000..e365771c83 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/animal.h @@ -0,0 +1,7 @@ +#pragma once + +class Animal { +public: + virtual void speak(); + virtual void move(); +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-diamond/duck.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/duck.cpp new file mode 100644 index 0000000000..49fecb3ffd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/duck.cpp @@ -0,0 +1,5 @@ +#include "duck.h" + +void Duck::speak() { + // quack +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-diamond/duck.h b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/duck.h new file mode 100644 index 0000000000..62ec1f95f9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/duck.h @@ -0,0 +1,8 @@ +#pragma once +#include "flyer.h" +#include "swimmer.h" + +class Duck : public Flyer, public Swimmer { +public: + void speak() override; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-diamond/flyer.h b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/flyer.h new file mode 100644 index 0000000000..2f47174dd8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/flyer.h @@ -0,0 +1,8 @@ +#pragma once +#include "animal.h" + +class Flyer : public Animal { +public: + void move() override; + void fly(); +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-diamond/swimmer.h b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/swimmer.h new file mode 100644 index 0000000000..23f75ed432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-diamond/swimmer.h @@ -0,0 +1,8 @@ +#pragma once +#include "animal.h" + +class Swimmer : public Animal { +public: + void move() override; + void swim(); +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-field-types/models.h b/gitnexus/test/fixtures/lang-resolution/cpp-field-types/models.h new file mode 100644 index 0000000000..0b91ffd264 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-field-types/models.h @@ -0,0 +1,20 @@ +#pragma once + +class Address { +public: + std::string city; + + void save() { + // persist address + } +}; + +class User { +public: + std::string name; + Address address; + + std::string greet() { + return name; + } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-field-types/service.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-field-types/service.cpp new file mode 100644 index 0000000000..4b90c656cb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-field-types/service.cpp @@ -0,0 +1,6 @@ +#include "models.h" + +void processUser(User user) { + // Field-access chain: user.address → Address, then .save() → Address#save + user.address.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/CMakeLists.txt b/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/CMakeLists.txt new file mode 100644 index 0000000000..b3badf8665 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/CMakeLists.txt @@ -0,0 +1,3 @@ +cmake_minimum_required(VERSION 3.10) +project(cpp-local-shadow) +add_executable(main src/main.cpp src/utils.cpp) diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/main.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/main.cpp new file mode 100644 index 0000000000..6784e2a047 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/main.cpp @@ -0,0 +1,15 @@ +#include "utils.h" + +// Local function shadows included save +void save(const char* data) { + printf("local save: %s\n", data); +} + +void run() { + save("test"); +} + +int main() { + run(); + return 0; +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/utils.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/utils.cpp new file mode 100644 index 0000000000..40d970ec5f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/utils.cpp @@ -0,0 +1,6 @@ +#include "utils.h" +#include <cstdio> + +void save(const char* data) { + printf("utils save: %s\n", data); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/utils.h b/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/utils.h new file mode 100644 index 0000000000..648fd3547c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-local-shadow/src/utils.h @@ -0,0 +1,3 @@ +#pragma once + +void save(const char* data); diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-member-calls/app.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-member-calls/app.cpp new file mode 100644 index 0000000000..1803665ee1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-member-calls/app.cpp @@ -0,0 +1,6 @@ +#include "user.h" + +void processUser() { + User user; + user.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-member-calls/user.h b/gitnexus/test/fixtures/lang-resolution/cpp-member-calls/user.h new file mode 100644 index 0000000000..489f99f923 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-member-calls/user.h @@ -0,0 +1,6 @@ +#pragma once + +class User { +public: + bool save() { return true; } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/models/Repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/models/Repo.h new file mode 100644 index 0000000000..8e02df5058 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/models/Repo.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class Repo { +public: + Repo(const std::string& dbName) : dbName_(dbName) {} + bool save() { return false; } +private: + std::string dbName_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/models/User.h b/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/models/User.h new file mode 100644 index 0000000000..44b48cd6d1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/models/User.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class User { +public: + User(const std::string& name) : name_(name) {} + bool save() { return true; } +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/services/App.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/services/App.cpp new file mode 100644 index 0000000000..2f42f2b964 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-nullable-receiver/services/App.cpp @@ -0,0 +1,19 @@ +#include "models/User.h" +#include "models/Repo.h" + +User* findUser() { + return new User("alice"); +} + +Repo* findRepo() { + return new Repo("maindb"); +} + +void processEntities() { + User* user = findUser(); + Repo* repo = findRepo(); + + // Pointer-based nullable receivers — should disambiguate via unwrapped type + user->save(); + repo->save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-parent-resolution/src/BaseModel.h b/gitnexus/test/fixtures/lang-resolution/cpp-parent-resolution/src/BaseModel.h new file mode 100644 index 0000000000..b53d615dbc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-parent-resolution/src/BaseModel.h @@ -0,0 +1,6 @@ +#pragma once + +class BaseModel { +public: + bool save() { return true; } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-parent-resolution/src/User.h b/gitnexus/test/fixtures/lang-resolution/cpp-parent-resolution/src/User.h new file mode 100644 index 0000000000..48f9273964 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-parent-resolution/src/User.h @@ -0,0 +1,7 @@ +#pragma once +#include "BaseModel.h" + +class User : public BaseModel { +public: + const char* serialize() { return ""; } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-pointer-ref-fields/models.h b/gitnexus/test/fixtures/lang-resolution/cpp-pointer-ref-fields/models.h new file mode 100644 index 0000000000..51443bc8a6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-pointer-ref-fields/models.h @@ -0,0 +1,21 @@ +#pragma once + +class Address { +public: + std::string city; + + void save() { + // persist address + } +}; + +class User { +public: + Address* address; // raw pointer member field + Address& ref_address; // reference member field + std::string name; + + std::string greet() { + return name; + } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-pointer-ref-fields/service.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-pointer-ref-fields/service.cpp new file mode 100644 index 0000000000..d7ffbfd774 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-pointer-ref-fields/service.cpp @@ -0,0 +1,6 @@ +#include "models.h" + +void processUser(User user) { + // Pointer member field access: user.address->save() + user.address->save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-range-for/App.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-range-for/App.cpp new file mode 100644 index 0000000000..79fb200954 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-range-for/App.cpp @@ -0,0 +1,15 @@ +#include "User.h" +#include "Repo.h" +#include <vector> + +void processUsers(const std::vector<User>& users) { + for (auto& user : users) { + user.save(); + } +} + +void processRepos(const std::vector<Repo>& repos) { + for (const auto& repo : repos) { + repo.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-range-for/Repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-range-for/Repo.h new file mode 100644 index 0000000000..b3858517cb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-range-for/Repo.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class Repo { +public: + Repo(const std::string& name) : name_(name) {} + void save() {} +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-range-for/User.h b/gitnexus/test/fixtures/lang-resolution/cpp-range-for/User.h new file mode 100644 index 0000000000..fdb2273541 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-range-for/User.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class User { +public: + User(const std::string& name) : name_(name) {} + void save() {} +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/app.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/app.cpp new file mode 100644 index 0000000000..a52f3e5e5f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/app.cpp @@ -0,0 +1,9 @@ +#include "user.h" +#include "repo.h" + +void processEntities() { + User user; + Repo repo; + user.save(); + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/repo.h new file mode 100644 index 0000000000..e57469f7c5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/repo.h @@ -0,0 +1,6 @@ +#pragma once + +class Repo { +public: + bool save() { return false; } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/user.h b/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/user.h new file mode 100644 index 0000000000..489f99f923 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-receiver-resolution/user.h @@ -0,0 +1,6 @@ +#pragma once + +class User { +public: + bool save() { return true; } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/app.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/app.cpp new file mode 100644 index 0000000000..60080a3495 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/app.cpp @@ -0,0 +1,20 @@ +#include "user.h" +#include "repo.h" + +User getUser(const char* name) { + return User(name); +} + +Repo getRepo(const char* name) { + return Repo(name); +} + +void processUser() { + auto user = getUser("alice"); + user.save(); +} + +void processRepo() { + auto repo = getRepo("main"); + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/repo.h new file mode 100644 index 0000000000..6331d23eb5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/repo.h @@ -0,0 +1,9 @@ +#pragma once + +class Repo { +public: + Repo(const char* name) : name_(name) {} + bool save() { return true; } +private: + const char* name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/user.h b/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/user.h new file mode 100644 index 0000000000..b1fb5928cf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-return-type-inference/user.h @@ -0,0 +1,9 @@ +#pragma once + +class User { +public: + User(const char* name) : name_(name) {} + bool save() { return true; } +private: + const char* name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-return-type/app.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-return-type/app.cpp new file mode 100644 index 0000000000..6925e024e1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-return-type/app.cpp @@ -0,0 +1,10 @@ +#include "user.h" + +User getUser(const char* name) { + return User(name); +} + +void processUser() { + auto user = getUser("alice"); + user.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-return-type/user.h b/gitnexus/test/fixtures/lang-resolution/cpp-return-type/user.h new file mode 100644 index 0000000000..df2ca19188 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-return-type/user.h @@ -0,0 +1,11 @@ +#pragma once + +class User { +public: + User(const char* name) : name_(name) {} + void save() {} +private: + const char* name_; +}; + +User getUser(const char* name); diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-scoped-brace-init/main.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-scoped-brace-init/main.cpp new file mode 100644 index 0000000000..a23f5c0da3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-scoped-brace-init/main.cpp @@ -0,0 +1,7 @@ +#include "models.h" + +void run() { + auto client = ns::HttpClient{}; + client.connect(); + client.send(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-scoped-brace-init/models.h b/gitnexus/test/fixtures/lang-resolution/cpp-scoped-brace-init/models.h new file mode 100644 index 0000000000..d216dae9e4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-scoped-brace-init/models.h @@ -0,0 +1,7 @@ +namespace ns { + class HttpClient { + public: + void connect() {} + void send() {} + }; +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-self-this-resolution/src/Repo.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-self-this-resolution/src/Repo.cpp new file mode 100644 index 0000000000..e95ca225b6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-self-this-resolution/src/Repo.cpp @@ -0,0 +1,4 @@ +class Repo { +public: + bool save() { return true; } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-self-this-resolution/src/User.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-self-this-resolution/src/User.cpp new file mode 100644 index 0000000000..7892d4784b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-self-this-resolution/src/User.cpp @@ -0,0 +1,7 @@ +class User { +public: + bool save() { return true; } + void process() { + this->save(); + } +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/App.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/App.cpp new file mode 100644 index 0000000000..bd2e390f3e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/App.cpp @@ -0,0 +1,17 @@ +#include "User.h" +#include "Repo.h" +#include <map> +#include <string> +#include <vector> + +void processUserMap(std::map<std::string, User> userMap) { + for (auto& [key, user] : userMap) { + user.save(); + } +} + +void processRepoMap(std::map<std::string, Repo> repoMap) { + for (const auto& [key, repo] : repoMap) { + repo.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/Repo.h b/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/Repo.h new file mode 100644 index 0000000000..b3858517cb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/Repo.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class Repo { +public: + Repo(const std::string& name) : name_(name) {} + void save() {} +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/User.h b/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/User.h new file mode 100644 index 0000000000..fdb2273541 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/User.h @@ -0,0 +1,10 @@ +#pragma once +#include <string> + +class User { +public: + User(const std::string& name) : name_(name) {} + void save() {} +private: + std::string name_; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-variadic-resolution/logger.h b/gitnexus/test/fixtures/lang-resolution/cpp-variadic-resolution/logger.h new file mode 100644 index 0000000000..56ace35be0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-variadic-resolution/logger.h @@ -0,0 +1,14 @@ +#ifndef LOGGER_H +#define LOGGER_H + +#include <cstdarg> +#include <cstdio> + +void log_entry(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); +} + +#endif diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-variadic-resolution/main.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-variadic-resolution/main.cpp new file mode 100644 index 0000000000..302869d893 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-variadic-resolution/main.cpp @@ -0,0 +1,6 @@ +#include "logger.h" + +int main() { + log_entry("hello %s %s", "world", "test"); + return 0; +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-write-access/models.h b/gitnexus/test/fixtures/lang-resolution/cpp-write-access/models.h new file mode 100644 index 0000000000..da9b5ee8f9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-write-access/models.h @@ -0,0 +1,12 @@ +#pragma once + +class Address { +public: + std::string city; +}; + +class User { +public: + std::string name; + Address address; +}; diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-write-access/service.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-write-access/service.cpp new file mode 100644 index 0000000000..91bce93fa0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/cpp-write-access/service.cpp @@ -0,0 +1,7 @@ +#include "models.h" + +void updateUser(User& user) { + user.name = "Alice"; + user.address = Address(); + user.name += " Smith"; +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/CsharpAlias.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/CsharpAlias.csproj new file mode 100644 index 0000000000..b14dd21d80 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/CsharpAlias.csproj @@ -0,0 +1,6 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <OutputType>Library</OutputType> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Models/Repo.cs new file mode 100644 index 0000000000..ea0c7c08cf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Models/Repo.cs @@ -0,0 +1,9 @@ +namespace Models +{ + public class Repo + { + public string Url { get; } + public Repo(string url) { Url = url; } + public bool Persist() => true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Models/User.cs new file mode 100644 index 0000000000..2d8b435005 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Models/User.cs @@ -0,0 +1,9 @@ +namespace Models +{ + public class User + { + public string Name { get; } + public User(string name) { Name = name; } + public bool Save() => true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Services/Main.cs b/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Services/Main.cs new file mode 100644 index 0000000000..3e34980e38 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-alias-imports/Services/Main.cs @@ -0,0 +1,16 @@ +using U = Models.User; +using R = Models.Repo; + +namespace Services +{ + public class Main + { + public void Run() + { + var u = new U("alice"); + var r = new R("https://example.com"); + u.Save(); + r.Persist(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Models/Handler.cs b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Models/Handler.cs new file mode 100644 index 0000000000..f15b0f2e2d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Models/Handler.cs @@ -0,0 +1,7 @@ +namespace MyApp.Models +{ + public class Handler + { + public void Handle() {} + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Models/IProcessor.cs b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Models/IProcessor.cs new file mode 100644 index 0000000000..afd54e61f3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Models/IProcessor.cs @@ -0,0 +1,7 @@ +namespace MyApp.Models +{ + public interface IProcessor + { + void Run(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Other/Handler.cs b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Other/Handler.cs new file mode 100644 index 0000000000..741dfba0a0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Other/Handler.cs @@ -0,0 +1,7 @@ +namespace MyApp.Other +{ + public class Handler + { + public void Process() {} + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Other/IProcessor.cs b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Other/IProcessor.cs new file mode 100644 index 0000000000..d96a3f6e0a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Other/IProcessor.cs @@ -0,0 +1,7 @@ +namespace MyApp.Other +{ + public interface IProcessor + { + void Execute(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Services/UserHandler.cs b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Services/UserHandler.cs new file mode 100644 index 0000000000..3135c077ee --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-ambiguous/Services/UserHandler.cs @@ -0,0 +1,9 @@ +using MyApp.Models; + +namespace MyApp.Services +{ + public class UserHandler : Handler, IProcessor + { + public void Run() {} + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/AssignmentChain.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/AssignmentChain.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/AssignmentChain.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Models/Repo.cs new file mode 100644 index 0000000000..fc587e48a2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Models/Repo.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class Repo +{ + public bool Save() + { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Models/User.cs new file mode 100644 index 0000000000..2d2ffe30a8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Models/User.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class User +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Program.cs b/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Program.cs new file mode 100644 index 0000000000..f327108363 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-assignment-chain/Program.cs @@ -0,0 +1,20 @@ +using Models; + +namespace App; + +public class Program +{ + static User GetUser() => new User(); + static Repo GetRepo() => new Repo(); + + public static void ProcessEntities() + { + User u = GetUser(); + var alias = u; + alias.Save(); + + Repo r = GetRepo(); + var rAlias = r; + rAlias.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/Order.cs b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/Order.cs new file mode 100644 index 0000000000..0c5cfab310 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/Order.cs @@ -0,0 +1,11 @@ +namespace CSharpAsyncBinding; + +public class Order +{ + public string Name { get; set; } + + public void Save() + { + // persist order + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/OrderService.cs b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/OrderService.cs new file mode 100644 index 0000000000..14eb7ad5bd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/OrderService.cs @@ -0,0 +1,9 @@ +namespace CSharpAsyncBinding; + +public class OrderService +{ + public async Task<Order> GetOrderAsync(string name) + { + return new Order { Name = name }; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/Program.cs b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/Program.cs new file mode 100644 index 0000000000..4da8b1505a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/Program.cs @@ -0,0 +1,24 @@ +namespace CSharpAsyncBinding; + +public class Program +{ + public static async Task Main(string[] args) + { + var userSvc = new UserService(); + var orderSvc = new OrderService(); + await ProcessUser(userSvc); + await ProcessOrder(orderSvc); + } + + public static async Task ProcessUser(UserService userSvc) + { + var user = await userSvc.GetUserAsync("alice"); + user.Save(); + } + + public static async Task ProcessOrder(OrderService orderSvc) + { + var order = await orderSvc.GetOrderAsync("bob"); + order.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/User.cs new file mode 100644 index 0000000000..218a5e8473 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/User.cs @@ -0,0 +1,11 @@ +namespace CSharpAsyncBinding; + +public class User +{ + public string Name { get; set; } + + public void Save() + { + // persist user + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/UserService.cs b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/UserService.cs new file mode 100644 index 0000000000..bf221e6517 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-async-binding/UserService.cs @@ -0,0 +1,9 @@ +namespace CSharpAsyncBinding; + +public class UserService +{ + public async Task<User> GetUserAsync(string name) + { + return new User { Name = name }; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-calls/CallProj.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-calls/CallProj.csproj new file mode 100644 index 0000000000..0acdb2bcc2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-calls/CallProj.csproj @@ -0,0 +1,6 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + <RootNamespace>CallProj</RootNamespace> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-calls/Services/UserService.cs b/gitnexus/test/fixtures/lang-resolution/csharp-calls/Services/UserService.cs new file mode 100644 index 0000000000..fc06399d0c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-calls/Services/UserService.cs @@ -0,0 +1,13 @@ +using static CallProj.Utils.OneArg; +using static CallProj.Utils.ZeroArg; + +namespace CallProj.Services +{ + public class UserService + { + public void CreateUser() + { + WriteAudit("hello"); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-calls/Utils/OneArg.cs b/gitnexus/test/fixtures/lang-resolution/csharp-calls/Utils/OneArg.cs new file mode 100644 index 0000000000..a5adb0b7a1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-calls/Utils/OneArg.cs @@ -0,0 +1,10 @@ +namespace CallProj.Utils +{ + public static class OneArg + { + public static string WriteAudit(string message) + { + return message; + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-calls/Utils/ZeroArg.cs b/gitnexus/test/fixtures/lang-resolution/csharp-calls/Utils/ZeroArg.cs new file mode 100644 index 0000000000..bde5bcd96e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-calls/Utils/ZeroArg.cs @@ -0,0 +1,10 @@ +namespace CallProj.Utils +{ + public static class ZeroArg + { + public static string WriteAudit() + { + return "zero"; + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Models/Repo.cs new file mode 100644 index 0000000000..e43cde2cdd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Models/Repo.cs @@ -0,0 +1,9 @@ +namespace ChainCall.Models; + +public class Repo +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Models/User.cs new file mode 100644 index 0000000000..dfff3d5913 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Models/User.cs @@ -0,0 +1,9 @@ +namespace ChainCall.Models; + +public class User +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Program.cs b/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Program.cs new file mode 100644 index 0000000000..40fb68ac68 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Program.cs @@ -0,0 +1,10 @@ +using ChainCall.Services; + +public class App +{ + public void ProcessUser() + { + var svc = new UserService(); + svc.GetUser().Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Services/UserService.cs b/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Services/UserService.cs new file mode 100644 index 0000000000..32e40b18b2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-chain-call/Services/UserService.cs @@ -0,0 +1,11 @@ +using ChainCall.Models; + +namespace ChainCall.Services; + +public class UserService +{ + public User GetUser() + { + return new User(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-deep-field-chain/Models.cs b/gitnexus/test/fixtures/lang-resolution/csharp-deep-field-chain/Models.cs new file mode 100644 index 0000000000..7e3b1ae00e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-deep-field-chain/Models.cs @@ -0,0 +1,33 @@ +namespace DeepFieldChain; + +public class City +{ + public string ZipCode { get; set; } + + public string GetName() + { + return "city"; + } +} + +public class Address +{ + public City City { get; set; } + public string Street { get; set; } + + public void Save() + { + // persist address + } +} + +public class User +{ + public string Name { get; set; } + public Address Address { get; set; } + + public string Greet() + { + return Name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-deep-field-chain/Service.cs b/gitnexus/test/fixtures/lang-resolution/csharp-deep-field-chain/Service.cs new file mode 100644 index 0000000000..52e8594bc0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-deep-field-chain/Service.cs @@ -0,0 +1,13 @@ +namespace DeepFieldChain; + +public class Service +{ + public static void ProcessUser(User user) + { + // 2-level chain: user.Address → Address, then .Save() → Address#Save + user.Address.Save(); + + // 3-level chain: user.Address → Address, .City → City, .GetName() → City#GetName + user.Address.City.GetName(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/App.cs b/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/App.cs new file mode 100644 index 0000000000..cd94c3653b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/App.cs @@ -0,0 +1,15 @@ +using System.Collections.Generic; + +public class App { + public void ProcessValues(Dictionary<string, User> data) { + foreach (var user in data.Values) { + user.Save(); + } + } + + public void ProcessList(List<User> users) { + foreach (var user in users) { + user.Save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/Repo.cs new file mode 100644 index 0000000000..0e8416a76f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/Repo.cs @@ -0,0 +1,4 @@ +public class Repo { + public string Name { get; set; } + public void Save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/User.cs new file mode 100644 index 0000000000..57c04e93b9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-dictionary-keys-values/User.cs @@ -0,0 +1,4 @@ +public class User { + public string Name { get; set; } + public void Save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-field-types/Models.cs b/gitnexus/test/fixtures/lang-resolution/csharp-field-types/Models.cs new file mode 100644 index 0000000000..191c7624ac --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-field-types/Models.cs @@ -0,0 +1,22 @@ +namespace FieldTypes; + +public class Address +{ + public string City { get; set; } + + public void Save() + { + // persist address + } +} + +public class User +{ + public string Name { get; set; } + public Address Address { get; set; } + + public string Greet() + { + return Name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-field-types/Service.cs b/gitnexus/test/fixtures/lang-resolution/csharp-field-types/Service.cs new file mode 100644 index 0000000000..48e01d7108 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-field-types/Service.cs @@ -0,0 +1,10 @@ +namespace FieldTypes; + +public class Service +{ + public static void ProcessUser(User user) + { + // Field-access chain: user.Address → Address, then .Save() → Address#Save + user.Address.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-foreach/ForeachProj.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-foreach/ForeachProj.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-foreach/ForeachProj.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Models/Repo.cs new file mode 100644 index 0000000000..fc587e48a2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Models/Repo.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class Repo +{ + public bool Save() + { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Models/User.cs new file mode 100644 index 0000000000..2d2ffe30a8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Models/User.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class User +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Program.cs b/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Program.cs new file mode 100644 index 0000000000..75c0da7c7e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-foreach/Program.cs @@ -0,0 +1,19 @@ +using Models; +using System.Collections.Generic; + +namespace App; + +public class AppService +{ + public void ProcessEntities(List<User> users, List<Repo> repos) + { + foreach (User user in users) + { + user.Save(); + } + foreach (Repo repo in repos) + { + repo.Save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/BaseModel.cs b/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/BaseModel.cs new file mode 100644 index 0000000000..9e4891e43c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/BaseModel.cs @@ -0,0 +1,5 @@ +namespace Models; + +public class BaseModel<T> { + public virtual bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/Repo.cs new file mode 100644 index 0000000000..60c1b2a079 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/Repo.cs @@ -0,0 +1,5 @@ +namespace Models; + +public class Repo { + public bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/User.cs new file mode 100644 index 0000000000..a9f7dd3188 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-generic-parent-resolution/src/Models/User.cs @@ -0,0 +1,8 @@ +namespace Models; + +public class User : BaseModel<string> { + public override bool Save() { + base.Save(); + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/IsPatternProj.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/IsPatternProj.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/IsPatternProj.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/models/Repo.cs new file mode 100644 index 0000000000..33d88e5a6d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/models/Repo.cs @@ -0,0 +1,6 @@ +namespace IsPattern.Models; + +public class Repo +{ + public void Save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/models/User.cs new file mode 100644 index 0000000000..5a742f216e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/models/User.cs @@ -0,0 +1,6 @@ +namespace IsPattern.Models; + +public class User +{ + public void Save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/services/App.cs b/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/services/App.cs new file mode 100644 index 0000000000..2a28ba7400 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-is-pattern/services/App.cs @@ -0,0 +1,14 @@ +using IsPattern.Models; + +namespace IsPattern.Services; + +public class App +{ + public void Process(object obj) + { + if (obj is User user) + { + user.Save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-local-shadow/App/Main.cs b/gitnexus/test/fixtures/lang-resolution/csharp-local-shadow/App/Main.cs new file mode 100644 index 0000000000..0b6f352692 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-local-shadow/App/Main.cs @@ -0,0 +1,14 @@ +using Utils; + +namespace App { + public class Main { + // Local method shadows imported Logger.Save + public static void Save(string data) { + System.Console.WriteLine("local save: " + data); + } + + public static void Run() { + Save("test"); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-local-shadow/Utils/Logger.cs b/gitnexus/test/fixtures/lang-resolution/csharp-local-shadow/Utils/Logger.cs new file mode 100644 index 0000000000..47507696af --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-local-shadow/Utils/Logger.cs @@ -0,0 +1,7 @@ +namespace Utils { + public class Logger { + public static void Save(string data) { + System.Console.WriteLine("utils save: " + data); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/MemberCallProj.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/MemberCallProj.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/MemberCallProj.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/Models/User.cs new file mode 100644 index 0000000000..2d2ffe30a8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/Models/User.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class User +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/Services/UserService.cs b/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/Services/UserService.cs new file mode 100644 index 0000000000..1d8e9e4db5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-member-calls/Services/UserService.cs @@ -0,0 +1,12 @@ +using Models; + +namespace Services; + +public class UserService +{ + public bool ProcessUser() + { + var user = new User(); + return user.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/MixedDeclChain.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/MixedDeclChain.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/MixedDeclChain.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Models/Repo.cs new file mode 100644 index 0000000000..f20237fd9d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Models/Repo.cs @@ -0,0 +1,4 @@ +public class Repo +{ + public bool Save() => false; +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Models/User.cs new file mode 100644 index 0000000000..605db19492 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Models/User.cs @@ -0,0 +1,4 @@ +public class User +{ + public bool Save() => true; +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Program.cs b/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Program.cs new file mode 100644 index 0000000000..f2565098b1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-mixed-decl-chain/Program.cs @@ -0,0 +1,29 @@ +// Tests assignment chain + is-pattern in the same file. +// The is-pattern (obj is User u) creates a Tier 0 binding; +// the assignment chain (var alias = u) propagates it via Tier 2. +// Also verifies that the type guard in extractPendingAssignment +// correctly skips is_pattern_expression nodes without breaking. +public class App +{ + public static void ProcessWithChain() + { + User u = new User(); + var alias = u; + alias.Save(); + } + + public static void ProcessWithPattern(object obj) + { + if (obj is User u) + { + u.Save(); + } + } + + public static void ProcessRepoChain() + { + Repo r = new Repo(); + var alias = r; + alias.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/App.cs b/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/App.cs new file mode 100644 index 0000000000..3550d259af --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/App.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; + +public class App { + private Dictionary<string, User> data; + + public void ProcessValues() { + foreach (var user in this.data.Values) { + user.Save(); + } + } + + public void ProcessKeys() { + foreach (var key in this.data.Keys) { + key.ToString(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/Repo.cs new file mode 100644 index 0000000000..0e8416a76f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/Repo.cs @@ -0,0 +1,4 @@ +public class Repo { + public string Name { get; set; } + public void Save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/User.cs new file mode 100644 index 0000000000..57c04e93b9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-nested-member-foreach/User.cs @@ -0,0 +1,4 @@ +public class User { + public string Name { get; set; } + public void Save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/App.cs b/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/App.cs new file mode 100644 index 0000000000..be7f9770bd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/App.cs @@ -0,0 +1,16 @@ +using Models; + +namespace App; + +public class AppService +{ + public void Process() + { + User? user = new User(); + Repo? repo = new Repo(); + + // Null-conditional calls — nullable receiver should be unwrapped + user?.Save(); + repo?.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/Models/Repo.cs new file mode 100644 index 0000000000..4b19312d8f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/Models/Repo.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class Repo +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/Models/User.cs new file mode 100644 index 0000000000..2d2ffe30a8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/Models/User.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class User +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/NullConditional.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/NullConditional.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-null-conditional/NullConditional.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/BaseModel.cs b/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/BaseModel.cs new file mode 100644 index 0000000000..a706110452 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/BaseModel.cs @@ -0,0 +1,5 @@ +namespace Models; + +public class BaseModel { + public bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/ISerializable.cs b/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/ISerializable.cs new file mode 100644 index 0000000000..4f90720964 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/ISerializable.cs @@ -0,0 +1,5 @@ +namespace Models; + +public interface ISerializable { + string Serialize(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/User.cs new file mode 100644 index 0000000000..0041bda76d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-parent-resolution/src/Models/User.cs @@ -0,0 +1,5 @@ +namespace Models; + +public class User : BaseModel, ISerializable { + public string Serialize() { return ""; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/Models/Animal.cs b/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/Models/Animal.cs new file mode 100644 index 0000000000..a940ba041c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/Models/Animal.cs @@ -0,0 +1,20 @@ +namespace Models; + +public class Animal +{ + public string Name { get; set; } +} + +public class Dog : Animal +{ + public void Bark() + { + } +} + +public class Cat : Animal +{ + public void Meow() + { + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/PatternMatchProj.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/PatternMatchProj.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/PatternMatchProj.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/Services/AnimalService.cs b/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/Services/AnimalService.cs new file mode 100644 index 0000000000..8a66f73228 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-pattern-matching/Services/AnimalService.cs @@ -0,0 +1,14 @@ +using Models; + +namespace Services; + +public class AnimalService +{ + public void HandleAnimal(Animal animal) + { + if (animal is Dog dog) + { + dog.Bark(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/App.cs b/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/App.cs new file mode 100644 index 0000000000..3439128be6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/App.cs @@ -0,0 +1,15 @@ +using Models; + +public class App +{ + public void Run() + { + // Explicit new + var user = new User("Alice", 30); + user.Save(); + + // Target-typed new (C# 9) + User user2 = new("Bob", 25); + user2.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/Models/Person.cs b/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/Models/Person.cs new file mode 100644 index 0000000000..1f3b109ac0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/Models/Person.cs @@ -0,0 +1,4 @@ +namespace Models; + +// C# 12 record with primary constructor +public record Person(string FirstName, string LastName); diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/Models/User.cs new file mode 100644 index 0000000000..334930e54b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-primary-ctors/Models/User.cs @@ -0,0 +1,10 @@ +namespace Models; + +// C# 12 primary constructor +public class User(string name, int age) +{ + public string Name => name; + public int Age => age; + + public void Save() { } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-proj/Interfaces/IRepository.cs b/gitnexus/test/fixtures/lang-resolution/csharp-proj/Interfaces/IRepository.cs new file mode 100644 index 0000000000..56bcd4eaba --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-proj/Interfaces/IRepository.cs @@ -0,0 +1,13 @@ +namespace MyApp.Interfaces +{ + public interface IRepository + { + void Save(); + void Delete(); + } + + public interface ILogger + { + void Log(string message); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-proj/Models/BaseEntity.cs b/gitnexus/test/fixtures/lang-resolution/csharp-proj/Models/BaseEntity.cs new file mode 100644 index 0000000000..035b98620e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-proj/Models/BaseEntity.cs @@ -0,0 +1,11 @@ +namespace MyApp.Models +{ + public class BaseEntity + { + public int Id { get; set; } + + public virtual void Validate() + { + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-proj/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-proj/Models/User.cs new file mode 100644 index 0000000000..69d857633b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-proj/Models/User.cs @@ -0,0 +1,21 @@ +using MyApp.Interfaces; + +namespace MyApp.Models +{ + public class User : BaseEntity, IRepository + { + public string Name { get; set; } + + public void Save() + { + } + + public void Delete() + { + } + + public override void Validate() + { + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-proj/Services/UserService.cs b/gitnexus/test/fixtures/lang-resolution/csharp-proj/Services/UserService.cs new file mode 100644 index 0000000000..f915194bfa --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-proj/Services/UserService.cs @@ -0,0 +1,19 @@ +using MyApp.Models; +using MyApp.Interfaces; + +namespace MyApp.Services +{ + public class UserService + { + private readonly IRepository _repo; + private readonly ILogger _logger; + + public void CreateUser(string name) + { + var user = new User(); + user.Validate(); + _repo.Save(); + _logger.Log("User created"); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/App.cs b/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/App.cs new file mode 100644 index 0000000000..01aedaee22 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/App.cs @@ -0,0 +1,14 @@ +using Models; + +namespace App; + +public class AppService +{ + public void ProcessEntities() + { + User user = new User(); + Repo repo = new Repo(); + user.Save(); + repo.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/Models/Repo.cs new file mode 100644 index 0000000000..fc587e48a2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/Models/Repo.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class Repo +{ + public bool Save() + { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/Models/User.cs new file mode 100644 index 0000000000..2d2ffe30a8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/Models/User.cs @@ -0,0 +1,9 @@ +namespace Models; + +public class User +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/ReceiverProj.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/ReceiverProj.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-receiver-resolution/ReceiverProj.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Models/Repo.cs new file mode 100644 index 0000000000..aa05916b18 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Models/Repo.cs @@ -0,0 +1,7 @@ +namespace Models; + +public class Repo +{ + public string Name { get; set; } = ""; + public bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Models/User.cs new file mode 100644 index 0000000000..77ec473641 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Models/User.cs @@ -0,0 +1,7 @@ +namespace Models; + +public class User +{ + public string Name { get; set; } = ""; + public bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Program.cs b/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Program.cs new file mode 100644 index 0000000000..429418670e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/Program.cs @@ -0,0 +1,20 @@ +using Models; + +namespace App; + +public class AppService +{ + public void ProcessWithRecursivePattern(object obj) + { + if (obj is User { Name: "Alice" } u) + { + u.Save(); + } + + var result = obj switch + { + Repo { Name: "main" } r => r.Save(), + _ => false + }; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/RecursivePatternProj.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/RecursivePatternProj.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-recursive-pattern/RecursivePatternProj.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Models/Repo.cs new file mode 100644 index 0000000000..3a5528cb10 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Models/Repo.cs @@ -0,0 +1,9 @@ +namespace ReturnType.Models; + +public class Repo +{ + public bool Save() + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Models/User.cs new file mode 100644 index 0000000000..453c83460d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Models/User.cs @@ -0,0 +1,24 @@ +namespace ReturnType.Models; + +public class User +{ + private string _name; + + public User(string name) + { + _name = name; + } + + public bool Save() + { + return true; + } +} + +public class UserService +{ + public User GetUser(string name) + { + return new User(name); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-return-type/ReturnType.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-return-type/ReturnType.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-return-type/ReturnType.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Services/App.cs b/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Services/App.cs new file mode 100644 index 0000000000..c3ccadac7b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-return-type/Services/App.cs @@ -0,0 +1,13 @@ +using ReturnType.Models; + +namespace ReturnType.Services; + +public class App +{ + public void Run() + { + var svc = new UserService(); + var user = svc.GetUser("alice"); + user.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-self-this-resolution/src/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-self-this-resolution/src/Models/Repo.cs new file mode 100644 index 0000000000..60c1b2a079 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-self-this-resolution/src/Models/Repo.cs @@ -0,0 +1,5 @@ +namespace Models; + +public class Repo { + public bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-self-this-resolution/src/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-self-this-resolution/src/Models/User.cs new file mode 100644 index 0000000000..84c36c1523 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-self-this-resolution/src/Models/User.cs @@ -0,0 +1,8 @@ +namespace Models; + +public class User { + public bool Save() { return true; } + public void Process() { + this.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/BaseModel.cs b/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/BaseModel.cs new file mode 100644 index 0000000000..f1b69c38fb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/BaseModel.cs @@ -0,0 +1,5 @@ +namespace Models; + +public class BaseModel { + public virtual bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/Repo.cs new file mode 100644 index 0000000000..60c1b2a079 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/Repo.cs @@ -0,0 +1,5 @@ +namespace Models; + +public class Repo { + public bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/User.cs new file mode 100644 index 0000000000..5773d64269 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-super-resolution/src/Models/User.cs @@ -0,0 +1,8 @@ +namespace Models; + +public class User : BaseModel { + public override bool Save() { + base.Save(); + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Models/Repo.cs new file mode 100644 index 0000000000..ff84d1899e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Models/Repo.cs @@ -0,0 +1,6 @@ +namespace Models; + +public class Repo +{ + public bool Save() { return false; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Models/User.cs new file mode 100644 index 0000000000..13aff18b34 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Models/User.cs @@ -0,0 +1,6 @@ +namespace Models; + +public class User +{ + public bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Program.cs b/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Program.cs new file mode 100644 index 0000000000..9f0e1dc6fd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/Program.cs @@ -0,0 +1,21 @@ +using Models; + +namespace App; + +public class AppService +{ + public void Process(object obj) + { + if (obj is User user) + { + user.Save(); + } + + switch (obj) + { + case Repo repo: + repo.Save(); + break; + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/SwitchPattern.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/SwitchPattern.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-switch-pattern/SwitchPattern.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Models/Repo.cs b/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Models/Repo.cs new file mode 100644 index 0000000000..ff84d1899e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Models/Repo.cs @@ -0,0 +1,6 @@ +namespace Models; + +public class Repo +{ + public bool Save() { return false; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Models/User.cs b/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Models/User.cs new file mode 100644 index 0000000000..13aff18b34 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Models/User.cs @@ -0,0 +1,6 @@ +namespace Models; + +public class User +{ + public bool Save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Program.cs b/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Program.cs new file mode 100644 index 0000000000..412c40013c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/Program.cs @@ -0,0 +1,29 @@ +using Models; +using System.Collections.Generic; + +namespace App; + +public class AppService +{ + public void ProcessUsers(List<User> users) + { + foreach (var user in users) + { + user.Save(); + } + } + + public void ProcessRepos(List<Repo> repos) + { + foreach (var repo in repos) + { + repo.Save(); + } + } + + public void Direct(User u, Repo r) + { + u.Save(); + r.Save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/VarForeach.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/VarForeach.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-var-foreach/VarForeach.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/Services/App.cs b/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/Services/App.cs new file mode 100644 index 0000000000..b9f3d4768a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/Services/App.cs @@ -0,0 +1,12 @@ +using static VariadicProj.Utils.Logger; + +namespace VariadicProj.Services +{ + public class App + { + public void Execute() + { + Record("hello", "world"); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/Utils/Logger.cs b/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/Utils/Logger.cs new file mode 100644 index 0000000000..1d72a5c2b9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/Utils/Logger.cs @@ -0,0 +1,10 @@ +namespace VariadicProj.Utils +{ + public static class Logger + { + public static string Record(params string[] args) + { + return string.Join(", ", args); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/VariadicProj.csproj b/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/VariadicProj.csproj new file mode 100644 index 0000000000..ec2cce1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-variadic-resolution/VariadicProj.csproj @@ -0,0 +1,5 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + </PropertyGroup> +</Project> diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-write-access/Models.cs b/gitnexus/test/fixtures/lang-resolution/csharp-write-access/Models.cs new file mode 100644 index 0000000000..c10cd60008 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-write-access/Models.cs @@ -0,0 +1,8 @@ +public class Address { + public string City { get; set; } +} + +public class User { + public string Name { get; set; } + public Address Address { get; set; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/csharp-write-access/Service.cs b/gitnexus/test/fixtures/lang-resolution/csharp-write-access/Service.cs new file mode 100644 index 0000000000..7ab39421ec --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/csharp-write-access/Service.cs @@ -0,0 +1,6 @@ +public class UserService { + public void UpdateUser(User user) { + user.Name = "Alice"; + user.Address = new Address(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/field-types/models.ts b/gitnexus/test/fixtures/lang-resolution/field-types/models.ts new file mode 100644 index 0000000000..4ac2d2109f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/field-types/models.ts @@ -0,0 +1,24 @@ +export class Address { + city: string; + + save(): void { + // persist address + } +} + +export class User { + name: string; + address: Address; + + greet(): string { + return this.name; + } +} + +export class Config { + static DEFAULT: Config = new Config(); + + validate(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/field-types/service.ts b/gitnexus/test/fixtures/lang-resolution/field-types/service.ts new file mode 100644 index 0000000000..ecb00b374f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/field-types/service.ts @@ -0,0 +1,11 @@ +import { User, Config } from './models'; + +function processUser(user: User) { + // Field-access chain: user.address resolves to Address, then .save() resolves to Address#save + user.address.save(); +} + +function validateConfig() { + // Static field access: Config.DEFAULT resolves to Config, then .validate() resolves to Config#validate + Config.DEFAULT.validate(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-ambiguous/go.mod b/gitnexus/test/fixtures/lang-resolution/go-ambiguous/go.mod new file mode 100644 index 0000000000..46f950fcfe --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-ambiguous/go.mod @@ -0,0 +1,3 @@ +module github.com/example/ambiguous + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/models/handler.go b/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/models/handler.go new file mode 100644 index 0000000000..0c75ac82dc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/models/handler.go @@ -0,0 +1,7 @@ +package models + +type Handler struct { + Name string +} + +func (h *Handler) Handle() {} diff --git a/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/other/handler.go b/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/other/handler.go new file mode 100644 index 0000000000..af7931e920 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/other/handler.go @@ -0,0 +1,7 @@ +package other + +type Handler struct { + ID int +} + +func (h *Handler) Process() {} diff --git a/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/services/user.go b/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/services/user.go new file mode 100644 index 0000000000..f47ffb4df6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-ambiguous/internal/services/user.go @@ -0,0 +1,9 @@ +package services + +import "github.com/example/ambiguous/internal/models" + +type UserHandler struct { + models.Handler +} + +func (u *UserHandler) Run() {} diff --git a/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/cmd/main.go new file mode 100644 index 0000000000..77745d00e1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/cmd/main.go @@ -0,0 +1,31 @@ +package main + +import "example.com/go-assignment-chain/models" + +func getUser() models.User { + return models.User{} +} + +func getRepo() models.Repo { + return models.Repo{} +} + +func processEntities() { + var u models.User = getUser() + alias := u + alias.Save() + + var r models.Repo = getRepo() + rAlias := r + rAlias.Save() +} + +func processWithVar() { + var u models.User = getUser() + var alias = u + alias.Save() + + var r models.Repo = getRepo() + var rAlias = r + rAlias.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/go.mod b/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/go.mod new file mode 100644 index 0000000000..ae305b7f7e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/go.mod @@ -0,0 +1,3 @@ +module example.com/go-assignment-chain + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/models/repo.go new file mode 100644 index 0000000000..25e42eaf55 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/models/repo.go @@ -0,0 +1,7 @@ +package models + +type Repo struct{} + +func (r *Repo) Save() bool { + return false +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/models/user.go new file mode 100644 index 0000000000..7307a10d6a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-assignment-chain/models/user.go @@ -0,0 +1,7 @@ +package models + +type User struct{} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-calls/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-calls/cmd/main.go new file mode 100644 index 0000000000..154d50d538 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-calls/cmd/main.go @@ -0,0 +1,10 @@ +package main + +import ( + . "example.com/go-calls/internal/onearg" + _ "example.com/go-calls/internal/zeroarg" +) + +func main() { + _ = WriteAudit("hello") +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-calls/go.mod b/gitnexus/test/fixtures/lang-resolution/go-calls/go.mod new file mode 100644 index 0000000000..0c02f08385 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-calls/go.mod @@ -0,0 +1,3 @@ +module example.com/go-calls + +go 1.22 diff --git a/gitnexus/test/fixtures/lang-resolution/go-calls/internal/onearg/log.go b/gitnexus/test/fixtures/lang-resolution/go-calls/internal/onearg/log.go new file mode 100644 index 0000000000..f92ba9871d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-calls/internal/onearg/log.go @@ -0,0 +1,5 @@ +package onearg + +func WriteAudit(message string) string { + return message +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-calls/internal/zeroarg/log.go b/gitnexus/test/fixtures/lang-resolution/go-calls/internal/zeroarg/log.go new file mode 100644 index 0000000000..f59538f6be --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-calls/internal/zeroarg/log.go @@ -0,0 +1,5 @@ +package zeroarg + +func WriteAudit() string { + return "zero" +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-chain-call/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-chain-call/cmd/main.go new file mode 100644 index 0000000000..ed0390d9fe --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-chain-call/cmd/main.go @@ -0,0 +1,14 @@ +package main + +import "example.com/chaincall/models" + +type UserService struct{} + +func (s *UserService) GetUser() *models.User { + return &models.User{Name: "alice"} +} + +func processUser() { + svc := &UserService{} + svc.GetUser().Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-chain-call/go.mod b/gitnexus/test/fixtures/lang-resolution/go-chain-call/go.mod new file mode 100644 index 0000000000..cc2e4ab02c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-chain-call/go.mod @@ -0,0 +1,3 @@ +module example.com/chaincall + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-chain-call/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-chain-call/models/repo.go new file mode 100644 index 0000000000..5abb2e7d82 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-chain-call/models/repo.go @@ -0,0 +1,9 @@ +package models + +type Repo struct { + Name string +} + +func (r *Repo) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-chain-call/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-chain-call/models/user.go new file mode 100644 index 0000000000..0e78a30a83 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-chain-call/models/user.go @@ -0,0 +1,9 @@ +package models + +type User struct { + Name string +} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/cmd/main.go new file mode 100644 index 0000000000..2b587af0de --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/cmd/main.go @@ -0,0 +1,10 @@ +package main + +import "example.com/go-constructor-type-inference/models" + +func processEntities() { + user := models.User{} + repo := models.Repo{} + user.Save() + repo.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/go.mod b/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/go.mod new file mode 100644 index 0000000000..4c2acbf0fa --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/go.mod @@ -0,0 +1,3 @@ +module example.com/go-constructor-type-inference + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/models/repo.go new file mode 100644 index 0000000000..25e42eaf55 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/models/repo.go @@ -0,0 +1,7 @@ +package models + +type Repo struct{} + +func (r *Repo) Save() bool { + return false +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/models/user.go new file mode 100644 index 0000000000..7307a10d6a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-constructor-type-inference/models/user.go @@ -0,0 +1,7 @@ +package models + +type User struct{} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/cmd/main.go new file mode 100644 index 0000000000..c848c9368e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/cmd/main.go @@ -0,0 +1,11 @@ +package main + +import "example.com/go-deep-field-chain/models" + +func processUser(user models.User) { + // 2-level chain: user.Address → Address, then .Save() → Address#Save + user.Address.Save() + + // 3-level chain: user.Address → Address, .City → City, .GetName() → City#GetName + user.Address.City.GetName() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/go.mod b/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/go.mod new file mode 100644 index 0000000000..f9f8e3511e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/go.mod @@ -0,0 +1,3 @@ +module example.com/go-deep-field-chain + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/models/models.go b/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/models/models.go new file mode 100644 index 0000000000..ac615e3854 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-deep-field-chain/models/models.go @@ -0,0 +1,27 @@ +package models + +type City struct { + ZipCode string +} + +func (c *City) GetName() string { + return "city" +} + +type Address struct { + City City + Street string +} + +func (a *Address) Save() bool { + return true +} + +type User struct { + Name string + Address Address +} + +func (u *User) Greet() string { + return u.Name +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-field-types/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-field-types/cmd/main.go new file mode 100644 index 0000000000..50b64f8167 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-field-types/cmd/main.go @@ -0,0 +1,8 @@ +package main + +import "example.com/go-field-types/models" + +func processUser(user models.User) { + // Field-access chain: user.Address → Address, then .Save() → Address#Save + user.Address.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-field-types/go.mod b/gitnexus/test/fixtures/lang-resolution/go-field-types/go.mod new file mode 100644 index 0000000000..86923ee6f3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-field-types/go.mod @@ -0,0 +1,3 @@ +module example.com/go-field-types + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-field-types/models/models.go b/gitnexus/test/fixtures/lang-resolution/go-field-types/models/models.go new file mode 100644 index 0000000000..e769f2bbfd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-field-types/models/models.go @@ -0,0 +1,18 @@ +package models + +type Address struct { + City string +} + +func (a *Address) Save() bool { + return true +} + +type User struct { + Name string + Address Address +} + +func (u *User) Greet() string { + return u.Name +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/cmd/main.go new file mode 100644 index 0000000000..7e2699d270 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/cmd/main.go @@ -0,0 +1,17 @@ +package main + +import "example.com/for-call-expr/models" + +func processUsers() { + for _, user := range models.GetUsers() { + user.Save() + } +} + +func processRepos() { + for _, repo := range models.GetRepos() { + repo.Save() + } +} + +func main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/go.mod b/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/go.mod new file mode 100644 index 0000000000..bd8bec4d7b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/go.mod @@ -0,0 +1,3 @@ +module example.com/for-call-expr + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/models/repo.go new file mode 100644 index 0000000000..5876603f1d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/models/repo.go @@ -0,0 +1,13 @@ +package models + +type Repo struct { + Name string +} + +func (r *Repo) Save() error { + return nil +} + +func GetRepos() []Repo { + return []Repo{{Name: "main"}} +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/models/user.go new file mode 100644 index 0000000000..97237bb4fb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-for-call-expr/models/user.go @@ -0,0 +1,13 @@ +package models + +type User struct { + Name string +} + +func (u *User) Save() error { + return nil +} + +func GetUsers() []User { + return []User{{Name: "alice"}} +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-local-shadow/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-local-shadow/cmd/main.go new file mode 100644 index 0000000000..f934f705dd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-local-shadow/cmd/main.go @@ -0,0 +1,12 @@ +package main + +import "go-local-shadow/internal/utils" + +func Save(data string) { + println("local save") +} + +func main() { + Save("test") + _ = utils.Save +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-local-shadow/go.mod b/gitnexus/test/fixtures/lang-resolution/go-local-shadow/go.mod new file mode 100644 index 0000000000..f0810679ee --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-local-shadow/go.mod @@ -0,0 +1,3 @@ +module go-local-shadow + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-local-shadow/internal/utils/utils.go b/gitnexus/test/fixtures/lang-resolution/go-local-shadow/internal/utils/utils.go new file mode 100644 index 0000000000..859b1ce0c9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-local-shadow/internal/utils/utils.go @@ -0,0 +1,5 @@ +package utils + +func Save(data string) { + println("saving from utils") +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-make-builtin/main.go b/gitnexus/test/fixtures/lang-resolution/go-make-builtin/main.go new file mode 100644 index 0000000000..d6a1976da8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-make-builtin/main.go @@ -0,0 +1,9 @@ +package main + +func main() { + sl := make([]User, 0) + sl[0].Save() + + m := make(map[string]User) + m["key"].Greet() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-make-builtin/models.go b/gitnexus/test/fixtures/lang-resolution/go-make-builtin/models.go new file mode 100644 index 0000000000..cedc8307d8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-make-builtin/models.go @@ -0,0 +1,10 @@ +package main + +type User struct { + Name string +} + +func (u *User) Save() {} +func (u *User) Greet() string { + return "Hello, " + u.Name +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-map-range/main.go b/gitnexus/test/fixtures/lang-resolution/go-map-range/main.go new file mode 100644 index 0000000000..344206dcd6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-map-range/main.go @@ -0,0 +1,9 @@ +package main + +import "models" + +func processMap(userMap map[string]models.User) { + for _, user := range userMap { + user.Save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-map-range/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-map-range/models/repo.go new file mode 100644 index 0000000000..ad306c8350 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-map-range/models/repo.go @@ -0,0 +1,7 @@ +package models + +type Repo struct { + Path string +} + +func (r Repo) Save() {} diff --git a/gitnexus/test/fixtures/lang-resolution/go-map-range/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-map-range/models/user.go new file mode 100644 index 0000000000..0c7df99e95 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-map-range/models/user.go @@ -0,0 +1,7 @@ +package models + +type User struct { + Name string +} + +func (u User) Save() {} diff --git a/gitnexus/test/fixtures/lang-resolution/go-member-calls/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-member-calls/cmd/main.go new file mode 100644 index 0000000000..1ad13299dd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-member-calls/cmd/main.go @@ -0,0 +1,8 @@ +package main + +import "example.com/go-member-calls/models" + +func processUser() bool { + user := models.User{} + return user.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-member-calls/go.mod b/gitnexus/test/fixtures/lang-resolution/go-member-calls/go.mod new file mode 100644 index 0000000000..e2fa0a761f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-member-calls/go.mod @@ -0,0 +1,3 @@ +module example.com/go-member-calls + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-member-calls/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-member-calls/models/user.go new file mode 100644 index 0000000000..7307a10d6a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-member-calls/models/user.go @@ -0,0 +1,7 @@ +package models + +type User struct{} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/cmd/main.go new file mode 100644 index 0000000000..5269dd6cf8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/cmd/main.go @@ -0,0 +1,11 @@ +package main + +import "example.com/go-mixed-chain/models" + +func processWithService(svc *models.UserService) { + svc.GetUser().Address.Save() +} + +func processWithUser(user *models.User) { + user.GetAddress().City.GetName() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/go.mod b/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/go.mod new file mode 100644 index 0000000000..e0b17c82b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/go.mod @@ -0,0 +1,3 @@ +module example.com/go-mixed-chain + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/models/models.go b/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/models/models.go new file mode 100644 index 0000000000..7e19915c73 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-mixed-chain/models/models.go @@ -0,0 +1,32 @@ +package models + +type City struct { + Name string +} + +func (c *City) GetName() string { + return c.Name +} + +type Address struct { + City City + Street string +} + +func (a *Address) Save() { +} + +type User struct { + Name string + Address Address +} + +func (u *User) GetAddress() *Address { + return &u.Address +} + +type UserService struct{} + +func (s *UserService) GetUser() *User { + return &User{} +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-multi-assign/app.go b/gitnexus/test/fixtures/lang-resolution/go-multi-assign/app.go new file mode 100644 index 0000000000..43a26502ca --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-multi-assign/app.go @@ -0,0 +1,7 @@ +package main + +func process(name string, url string) { + user, repo := User{Name: name}, Repo{URL: url} + user.Save() + repo.Persist() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-multi-assign/models.go b/gitnexus/test/fixtures/lang-resolution/go-multi-assign/models.go new file mode 100644 index 0000000000..263b6dc5a2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-multi-assign/models.go @@ -0,0 +1,17 @@ +package main + +type User struct { + Name string +} + +func (u *User) Save() bool { + return true +} + +type Repo struct { + URL string +} + +func (r *Repo) Persist() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/cmd/main.go new file mode 100644 index 0000000000..5d88f68c99 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/cmd/main.go @@ -0,0 +1,24 @@ +package main + +import "example.com/multireturn/models" + +func NewUser(name string) (*models.User, error) { + return &models.User{Name: name}, nil +} + +func NewRepo(name string) (*models.Repo, error) { + return &models.Repo{Name: name}, nil +} + +func processUser() { + user, err := NewUser("alice") + if err != nil { + return + } + user.Save() +} + +func processRepo() { + repo, _ := NewRepo("main") + repo.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/go.mod b/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/go.mod new file mode 100644 index 0000000000..31de69be1a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/go.mod @@ -0,0 +1,3 @@ +module example.com/multireturn + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/models/repo.go new file mode 100644 index 0000000000..5abb2e7d82 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/models/repo.go @@ -0,0 +1,9 @@ +package models + +type Repo struct { + Name string +} + +func (r *Repo) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/models/user.go new file mode 100644 index 0000000000..0e78a30a83 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-multi-return-inference/models/user.go @@ -0,0 +1,9 @@ +package models + +type User struct { + Name string +} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-new-builtin/main.go b/gitnexus/test/fixtures/lang-resolution/go-new-builtin/main.go new file mode 100644 index 0000000000..6da0937341 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-new-builtin/main.go @@ -0,0 +1,7 @@ +package main + +func main() { + user := new(User) + user.Save() + user.Greet() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-new-builtin/models.go b/gitnexus/test/fixtures/lang-resolution/go-new-builtin/models.go new file mode 100644 index 0000000000..f83199ae02 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-new-builtin/models.go @@ -0,0 +1,11 @@ +package main + +type User struct { + Name string + Age int +} + +func (u *User) Save() {} +func (u *User) Greet() string { + return "Hello, " + u.Name +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/cmd/main.go new file mode 100644 index 0000000000..b38f62555b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/cmd/main.go @@ -0,0 +1,18 @@ +package main + +import "example.com/go-nullable-receiver/models" + +func findUser() *models.User { + return &models.User{} +} + +func findRepo() *models.Repo { + return &models.Repo{} +} + +func processEntities() { + var user *models.User = findUser() + var repo *models.Repo = findRepo() + user.Save() + repo.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/go.mod b/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/go.mod new file mode 100644 index 0000000000..5a9859a881 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/go.mod @@ -0,0 +1,3 @@ +module example.com/go-nullable-receiver + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/models/repo.go new file mode 100644 index 0000000000..25e42eaf55 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/models/repo.go @@ -0,0 +1,7 @@ +package models + +type Repo struct{} + +func (r *Repo) Save() bool { + return false +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/models/user.go new file mode 100644 index 0000000000..7307a10d6a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-nullable-receiver/models/user.go @@ -0,0 +1,7 @@ +package models + +type User struct{} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/go.mod b/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/go.mod new file mode 100644 index 0000000000..192e075e86 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/go.mod @@ -0,0 +1,3 @@ +module example.com/app + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/models/base.go b/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/models/base.go new file mode 100644 index 0000000000..f402c29da6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/models/base.go @@ -0,0 +1,7 @@ +package models + +type BaseModel struct{} + +func (b *BaseModel) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/models/user.go new file mode 100644 index 0000000000..bf962a773d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-parent-resolution/models/user.go @@ -0,0 +1,9 @@ +package models + +type User struct { + BaseModel +} + +func (u *User) Serialize() string { + return "" +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-pkg/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-pkg/cmd/main.go new file mode 100644 index 0000000000..1bb052eb61 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pkg/cmd/main.go @@ -0,0 +1,13 @@ +package main + +import ( + "github.com/example/gopkg/internal/auth" + "github.com/example/gopkg/internal/models" +) + +func main() { + user := auth.Authenticate("alice") + _ = models.NewUser("bob") + _ = models.NewAdmin("charlie", "superadmin") + _ = user +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-pkg/go.mod b/gitnexus/test/fixtures/lang-resolution/go-pkg/go.mod new file mode 100644 index 0000000000..41ba6c644d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pkg/go.mod @@ -0,0 +1,3 @@ +module github.com/example/gopkg + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/auth/service.go b/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/auth/service.go new file mode 100644 index 0000000000..ce14c339f2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/auth/service.go @@ -0,0 +1,12 @@ +package auth + +import "github.com/example/gopkg/internal/models" + +func Authenticate(name string) *models.User { + user := models.NewUser(name) + return user +} + +func ValidateToken(token string) bool { + return len(token) > 0 +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/admin.go b/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/admin.go new file mode 100644 index 0000000000..e94eaad65e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/admin.go @@ -0,0 +1,10 @@ +package models + +type Admin struct { + User + Role string +} + +func NewAdmin(name string, role string) *Admin { + return &Admin{User: *NewUser(name), Role: role} +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/repository.go b/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/repository.go new file mode 100644 index 0000000000..59cd41ac87 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/repository.go @@ -0,0 +1,6 @@ +package models + +type Repository interface { + Save(user *User) error + FindByID(id int) (*User, error) +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/user.go new file mode 100644 index 0000000000..68540a7025 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pkg/internal/models/user.go @@ -0,0 +1,10 @@ +package models + +type User struct { + ID int + Name string +} + +func NewUser(name string) *User { + return &User{Name: name} +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/cmd/main.go new file mode 100644 index 0000000000..21349e23d5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/cmd/main.go @@ -0,0 +1,11 @@ +package main + +import "example.com/pointer-test/models" + +func process() { + user := &models.User{Name: "alice"} + user.Save() + + repo := &models.Repo{Name: "test"} + repo.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/go.mod b/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/go.mod new file mode 100644 index 0000000000..bba0365249 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/go.mod @@ -0,0 +1,3 @@ +module example.com/pointer-test + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/models/repo.go new file mode 100644 index 0000000000..5abb2e7d82 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/models/repo.go @@ -0,0 +1,9 @@ +package models + +type Repo struct { + Name string +} + +func (r *Repo) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/models/user.go new file mode 100644 index 0000000000..0e78a30a83 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-pointer-constructor-inference/models/user.go @@ -0,0 +1,9 @@ +package models + +type User struct { + Name string +} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/cmd/main.go new file mode 100644 index 0000000000..720b177615 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/cmd/main.go @@ -0,0 +1,10 @@ +package main + +import "example.com/go-receiver-resolution/models" + +func processEntities() { + var user models.User + var repo models.Repo + user.Save() + repo.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/go.mod b/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/go.mod new file mode 100644 index 0000000000..7592619a31 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/go.mod @@ -0,0 +1,3 @@ +module example.com/go-receiver-resolution + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/models/repo.go new file mode 100644 index 0000000000..25e42eaf55 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/models/repo.go @@ -0,0 +1,7 @@ +package models + +type Repo struct{} + +func (r *Repo) Save() bool { + return false +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/models/user.go new file mode 100644 index 0000000000..7307a10d6a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-receiver-resolution/models/user.go @@ -0,0 +1,7 @@ +package models + +type User struct{} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/cmd/main.go new file mode 100644 index 0000000000..fda782be15 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/cmd/main.go @@ -0,0 +1,27 @@ +package main + +import "example.com/returntype/models" + +func GetUser(name string) *models.User { + return &models.User{Name: name} +} + +func processUser() { + user := GetUser("alice") + user.Save() +} + +// Cross-package factory call: models.NewUser() uses selector_expression in the AST +func processUserCrossPackage() { + user := models.NewUser("bob") + user.Save() +} + +func GetRepo(name string) *models.Repo { + return &models.Repo{Name: name} +} + +func processRepo() { + repo := GetRepo("main") + repo.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/go.mod b/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/go.mod new file mode 100644 index 0000000000..9cdbfe303a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/go.mod @@ -0,0 +1,3 @@ +module example.com/returntype + +go 1.21 diff --git a/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/models/repo.go b/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/models/repo.go new file mode 100644 index 0000000000..69bbe0895c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/models/repo.go @@ -0,0 +1,13 @@ +package models + +type Repo struct { + Name string +} + +func (r *Repo) Save() bool { + return true +} + +func GetRepo(name string) *Repo { + return &Repo{Name: name} +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/models/user.go b/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/models/user.go new file mode 100644 index 0000000000..c3714ff74d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-return-type-inference/models/user.go @@ -0,0 +1,13 @@ +package models + +type User struct { + Name string +} + +func (u *User) Save() bool { + return true +} + +func NewUser(name string) *User { + return &User{Name: name} +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-struct-literals/app.go b/gitnexus/test/fixtures/lang-resolution/go-struct-literals/app.go new file mode 100644 index 0000000000..627fe8e5d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-struct-literals/app.go @@ -0,0 +1,6 @@ +package main + +func processUser(name string) { + user := User{Name: name} + user.Save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-struct-literals/user.go b/gitnexus/test/fixtures/lang-resolution/go-struct-literals/user.go new file mode 100644 index 0000000000..b5e55c687c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-struct-literals/user.go @@ -0,0 +1,9 @@ +package main + +type User struct { + Name string +} + +func (u *User) Save() bool { + return true +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-type-assertion/main.go b/gitnexus/test/fixtures/lang-resolution/go-type-assertion/main.go new file mode 100644 index 0000000000..016562c7cb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-type-assertion/main.go @@ -0,0 +1,7 @@ +package main + +func process(s Saver) { + user := s.(User) + user.Save() + user.Greet() +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-type-assertion/models.go b/gitnexus/test/fixtures/lang-resolution/go-type-assertion/models.go new file mode 100644 index 0000000000..b5cb732f38 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-type-assertion/models.go @@ -0,0 +1,14 @@ +package main + +type Saver interface { + Save() +} + +type User struct { + Name string +} + +func (u *User) Save() {} +func (u *User) Greet() string { + return "Hello, " + u.Name +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/cmd/main.go b/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/cmd/main.go new file mode 100644 index 0000000000..9915da6fbc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/cmd/main.go @@ -0,0 +1,7 @@ +package main + +import . "example.com/go-variadic-resolution/internal/logger" + +func main() { + Entry("hello", "world", "test") +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/go.mod b/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/go.mod new file mode 100644 index 0000000000..6a3adc9093 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/go.mod @@ -0,0 +1,3 @@ +module example.com/go-variadic-resolution + +go 1.22 diff --git a/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/internal/logger/logger.go b/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/internal/logger/logger.go new file mode 100644 index 0000000000..a3bd0779ef --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-variadic-resolution/internal/logger/logger.go @@ -0,0 +1,5 @@ +package logger + +func Entry(args ...interface{}) { + _ = args +} diff --git a/gitnexus/test/fixtures/lang-resolution/go-write-access/main.go b/gitnexus/test/fixtures/lang-resolution/go-write-access/main.go new file mode 100644 index 0000000000..204fbda529 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/go-write-access/main.go @@ -0,0 +1,15 @@ +package main + +type Address struct { + City string +} + +type User struct { + Name string + Address Address +} + +func updateUser(user *User) { + user.Name = "Alice" + user.Address = Address{City: "NYC"} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-ambiguous/models/Handler.java b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/models/Handler.java new file mode 100644 index 0000000000..98d4fd4cd0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/models/Handler.java @@ -0,0 +1,5 @@ +package models; + +public class Handler { + public void handle() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-ambiguous/models/Processor.java b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/models/Processor.java new file mode 100644 index 0000000000..3cc9502be4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/models/Processor.java @@ -0,0 +1,5 @@ +package models; + +public interface Processor { + void run(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-ambiguous/other/Handler.java b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/other/Handler.java new file mode 100644 index 0000000000..486a645214 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/other/Handler.java @@ -0,0 +1,5 @@ +package other; + +public class Handler { + public void process() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-ambiguous/other/Processor.java b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/other/Processor.java new file mode 100644 index 0000000000..56f7cf2669 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/other/Processor.java @@ -0,0 +1,5 @@ +package other; + +public interface Processor { + void execute(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-ambiguous/services/UserHandler.java b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/services/UserHandler.java new file mode 100644 index 0000000000..8dac8e1b0e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-ambiguous/services/UserHandler.java @@ -0,0 +1,8 @@ +package services; + +import models.Handler; +import models.Processor; + +public class UserHandler extends Handler implements Processor { + public void run() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/App.java b/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/App.java new file mode 100644 index 0000000000..a41cdbcb3e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/App.java @@ -0,0 +1,17 @@ +import models.User; +import models.Repo; + +public class App { + static User getUser() { return new User(); } + static Repo getRepo() { return new Repo(); } + + public static void processEntities() { + User u = getUser(); + var alias = u; + alias.save(); + + Repo r = getRepo(); + var rAlias = r; + rAlias.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/models/Repo.java new file mode 100644 index 0000000000..cf3712bbca --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/models/Repo.java @@ -0,0 +1,7 @@ +package models; + +public class Repo { + public boolean save() { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/models/User.java new file mode 100644 index 0000000000..e8dacc1360 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-assignment-chain/models/User.java @@ -0,0 +1,7 @@ +package models; + +public class User { + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-calls/services/UserService.java b/gitnexus/test/fixtures/lang-resolution/java-calls/services/UserService.java new file mode 100644 index 0000000000..2a3436a9d1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-calls/services/UserService.java @@ -0,0 +1,10 @@ +package services; + +import static util.OneArg.writeAudit; +import static util.ZeroArg.writeAudit; + +public class UserService { + public void processUser() { + writeAudit("hello"); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-calls/util/OneArg.java b/gitnexus/test/fixtures/lang-resolution/java-calls/util/OneArg.java new file mode 100644 index 0000000000..f5ef77f3f6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-calls/util/OneArg.java @@ -0,0 +1,7 @@ +package util; + +public class OneArg { + public static String writeAudit(String message) { + return message; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-calls/util/ZeroArg.java b/gitnexus/test/fixtures/lang-resolution/java-calls/util/ZeroArg.java new file mode 100644 index 0000000000..4833f188d4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-calls/util/ZeroArg.java @@ -0,0 +1,7 @@ +package util; + +public class ZeroArg { + public static String writeAudit() { + return "zero"; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-chain-call/App.java b/gitnexus/test/fixtures/lang-resolution/java-chain-call/App.java new file mode 100644 index 0000000000..8e58ee1ca6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-chain-call/App.java @@ -0,0 +1,8 @@ +import services.UserService; + +public class App { + public static void processUser() { + UserService svc = new UserService(); + svc.getUser().save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-chain-call/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-chain-call/models/Repo.java new file mode 100644 index 0000000000..4908ace6de --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-chain-call/models/Repo.java @@ -0,0 +1,7 @@ +package models; + +public class Repo { + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-chain-call/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-chain-call/models/User.java new file mode 100644 index 0000000000..e8dacc1360 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-chain-call/models/User.java @@ -0,0 +1,7 @@ +package models; + +public class User { + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-chain-call/services/UserService.java b/gitnexus/test/fixtures/lang-resolution/java-chain-call/services/UserService.java new file mode 100644 index 0000000000..fe18a97b0e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-chain-call/services/UserService.java @@ -0,0 +1,9 @@ +package services; + +import models.User; + +public class UserService { + public User getUser() { + return new User(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-constructor-calls/App.java b/gitnexus/test/fixtures/lang-resolution/java-constructor-calls/App.java new file mode 100644 index 0000000000..5546d70d45 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-constructor-calls/App.java @@ -0,0 +1,8 @@ +import models.User; + +public class App { + public static void processUser(String name) { + User user = new User(name); + user.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-constructor-calls/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-constructor-calls/models/User.java new file mode 100644 index 0000000000..9d605797e3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-constructor-calls/models/User.java @@ -0,0 +1,13 @@ +package models; + +public class User { + private String name; + + public User(String name) { + this.name = name; + } + + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/App.java b/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/App.java new file mode 100644 index 0000000000..c39f5a99dc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/App.java @@ -0,0 +1,11 @@ +import models.User; +import models.Repo; + +public class App { + public static void processEntities() { + var user = new User(); + var repo = new Repo(); + user.save(); + repo.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/models/Repo.java new file mode 100644 index 0000000000..cf3712bbca --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/models/Repo.java @@ -0,0 +1,7 @@ +package models; + +public class Repo { + public boolean save() { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/models/User.java new file mode 100644 index 0000000000..e8dacc1360 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-constructor-type-inference/models/User.java @@ -0,0 +1,7 @@ +package models; + +public class User { + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/App.java b/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/App.java new file mode 100644 index 0000000000..a158e61680 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/App.java @@ -0,0 +1,11 @@ +import models.User; + +public class App { + public static void processUser(User user) { + // 2-level chain: user.address → Address, then .save() → Address#save + user.address.save(); + + // 3-level chain: user.address → Address, .city → City, .getName() → City#getName + user.address.city.getName(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/Address.java b/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/Address.java new file mode 100644 index 0000000000..c89d8132c0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/Address.java @@ -0,0 +1,10 @@ +package models; + +public class Address { + public City city; + public String street; + + public void save() { + // persist address + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/City.java b/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/City.java new file mode 100644 index 0000000000..c843c5cccd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/City.java @@ -0,0 +1,9 @@ +package models; + +public class City { + public String zipCode; + + public String getName() { + return "city"; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/User.java new file mode 100644 index 0000000000..dc3b7e76a4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-deep-field-chain/models/User.java @@ -0,0 +1,10 @@ +package models; + +public class User { + public String name; + public Address address; + + public String greet() { + return this.name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-enum-static-call/src/App.java b/gitnexus/test/fixtures/lang-resolution/java-enum-static-call/src/App.java new file mode 100644 index 0000000000..587716581c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-enum-static-call/src/App.java @@ -0,0 +1,6 @@ +public class App { + public void process() { + Status s = Status.fromCode(200); + s.label(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-enum-static-call/src/Status.java b/gitnexus/test/fixtures/lang-resolution/java-enum-static-call/src/Status.java new file mode 100644 index 0000000000..a533cbf07e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-enum-static-call/src/Status.java @@ -0,0 +1,12 @@ +public enum Status { + OK, + ERROR; + + public static Status fromCode(int code) { + return code == 200 ? OK : ERROR; + } + + public String label() { + return this.name().toLowerCase(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-field-types/App.java b/gitnexus/test/fixtures/lang-resolution/java-field-types/App.java new file mode 100644 index 0000000000..1ba64e00e1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-field-types/App.java @@ -0,0 +1,8 @@ +import models.User; + +public class App { + public static void processUser(User user) { + // Field-access chain: user.address → Address, then .save() → Address#save + user.address.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-field-types/models/Address.java b/gitnexus/test/fixtures/lang-resolution/java-field-types/models/Address.java new file mode 100644 index 0000000000..40107bbf1a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-field-types/models/Address.java @@ -0,0 +1,9 @@ +package models; + +public class Address { + public String city; + + public void save() { + // persist address + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-field-types/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-field-types/models/User.java new file mode 100644 index 0000000000..dc3b7e76a4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-field-types/models/User.java @@ -0,0 +1,10 @@ +package models; + +public class User { + public String name; + public Address address; + + public String greet() { + return this.name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/Main.java b/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/Main.java new file mode 100644 index 0000000000..38b79025f1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/Main.java @@ -0,0 +1,16 @@ +import models.User; +import models.Repo; + +public class Main { + void processUsers() { + for (User user : User.getUsers()) { + user.save(); + } + } + + void processRepos() { + for (Repo repo : Repo.getRepos()) { + repo.save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/models/Repo.java new file mode 100644 index 0000000000..be7f2b8309 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/models/Repo.java @@ -0,0 +1,17 @@ +package models; + +import java.util.List; + +public class Repo { + private String name; + + public Repo(String name) { + this.name = name; + } + + public void save() {} + + public static List<Repo> getRepos() { + return List.of(new Repo("main")); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/models/User.java new file mode 100644 index 0000000000..f6470958d9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-foreach-call-expr/models/User.java @@ -0,0 +1,17 @@ +package models; + +import java.util.List; + +public class User { + private String name; + + public User(String name) { + this.name = name; + } + + public void save() {} + + public static List<User> getUsers() { + return List.of(new User("alice")); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-foreach/App.java b/gitnexus/test/fixtures/lang-resolution/java-foreach/App.java new file mode 100644 index 0000000000..a3675e1022 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-foreach/App.java @@ -0,0 +1,13 @@ +import models.User; +import models.Repo; + +public class App { + public static void processEntities(User[] users, Repo[] repos) { + for (User user : users) { + user.save(); + } + for (Repo repo : repos) { + repo.save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-foreach/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-foreach/models/Repo.java new file mode 100644 index 0000000000..cf3712bbca --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-foreach/models/Repo.java @@ -0,0 +1,7 @@ +package models; + +public class Repo { + public boolean save() { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-foreach/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-foreach/models/User.java new file mode 100644 index 0000000000..e8dacc1360 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-foreach/models/User.java @@ -0,0 +1,7 @@ +package models; + +public class User { + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/BaseModel.java b/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/BaseModel.java new file mode 100644 index 0000000000..601bee4762 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/BaseModel.java @@ -0,0 +1,5 @@ +package models; + +public class BaseModel<T> { + public boolean save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/Repo.java new file mode 100644 index 0000000000..4abcdfce8c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/Repo.java @@ -0,0 +1,5 @@ +package models; + +public class Repo { + public boolean save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/User.java new file mode 100644 index 0000000000..ce96757356 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-generic-parent-resolution/src/models/User.java @@ -0,0 +1,8 @@ +package models; + +public class User extends BaseModel<String> { + public boolean save() { + super.save(); + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-heritage/interfaces/Serializable.java b/gitnexus/test/fixtures/lang-resolution/java-heritage/interfaces/Serializable.java new file mode 100644 index 0000000000..473baf6434 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-heritage/interfaces/Serializable.java @@ -0,0 +1,6 @@ +package interfaces; + +public interface Serializable { + String serialize(); + void deserialize(String data); +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-heritage/interfaces/Validatable.java b/gitnexus/test/fixtures/lang-resolution/java-heritage/interfaces/Validatable.java new file mode 100644 index 0000000000..82961b2cdf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-heritage/interfaces/Validatable.java @@ -0,0 +1,5 @@ +package interfaces; + +public interface Validatable { + boolean validate(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-heritage/models/BaseModel.java b/gitnexus/test/fixtures/lang-resolution/java-heritage/models/BaseModel.java new file mode 100644 index 0000000000..dfd2d41870 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-heritage/models/BaseModel.java @@ -0,0 +1,12 @@ +package models; + +public class BaseModel { + protected int id; + + public int getId() { + return id; + } + + public void save() { + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-heritage/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-heritage/models/User.java new file mode 100644 index 0000000000..2039f9fcc2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-heritage/models/User.java @@ -0,0 +1,20 @@ +package models; + +import interfaces.Serializable; +import interfaces.Validatable; + +public class User extends BaseModel implements Serializable, Validatable { + private String name; + + public String serialize() { + return name; + } + + public void deserialize(String data) { + this.name = data; + } + + public boolean validate() { + return name != null; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-heritage/services/UserService.java b/gitnexus/test/fixtures/lang-resolution/java-heritage/services/UserService.java new file mode 100644 index 0000000000..9695733857 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-heritage/services/UserService.java @@ -0,0 +1,12 @@ +package services; + +import models.User; +import interfaces.Serializable; + +public class UserService { + public void processUser(User user) { + user.validate(); + user.save(); + String data = user.serialize(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/models/Repo.java new file mode 100644 index 0000000000..acd3d3991a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/models/Repo.java @@ -0,0 +1,5 @@ +package models; + +public class Repo { + public void save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/models/User.java new file mode 100644 index 0000000000..4bb7299936 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/models/User.java @@ -0,0 +1,5 @@ +package models; + +public class User { + public void save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/services/App.java b/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/services/App.java new file mode 100644 index 0000000000..fd23b5f42e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-instanceof-pattern/services/App.java @@ -0,0 +1,12 @@ +package services; + +import models.User; +import models.Repo; + +public class App { + public void process(Object obj) { + if (obj instanceof User user) { + user.save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-local-shadow/src/main/java/com/example/app/Main.java b/gitnexus/test/fixtures/lang-resolution/java-local-shadow/src/main/java/com/example/app/Main.java new file mode 100644 index 0000000000..b262e6c940 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-local-shadow/src/main/java/com/example/app/Main.java @@ -0,0 +1,14 @@ +package com.example.app; + +import com.example.utils.Logger; + +public class Main { + // Local method shadows imported Logger.save + public static void save(String data) { + System.out.println("local save: " + data); + } + + public static void run() { + save("test"); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-local-shadow/src/main/java/com/example/utils/Logger.java b/gitnexus/test/fixtures/lang-resolution/java-local-shadow/src/main/java/com/example/utils/Logger.java new file mode 100644 index 0000000000..15a4005d26 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-local-shadow/src/main/java/com/example/utils/Logger.java @@ -0,0 +1,7 @@ +package com.example.utils; + +public class Logger { + public static void save(String data) { + System.out.println("utils save: " + data); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/App.java b/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/App.java new file mode 100644 index 0000000000..2641fc4a4d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/App.java @@ -0,0 +1,18 @@ +package src; + +import java.util.Map; +import java.util.List; + +public class App { + public void processValues(Map<String, User> data) { + for (var user : data.values()) { + user.save(); + } + } + + public void processList(List<User> users) { + for (var user : users) { + user.save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/Repo.java new file mode 100644 index 0000000000..2ec27c97a8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/Repo.java @@ -0,0 +1,7 @@ +package src; + +public class Repo { + private String name; + public Repo(String name) { this.name = name; } + public void save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/User.java b/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/User.java new file mode 100644 index 0000000000..6fe76df2a1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-map-keys-values/src/User.java @@ -0,0 +1,7 @@ +package src; + +public class User { + private String name; + public User(String name) { this.name = name; } + public void save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-member-calls/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-member-calls/models/User.java new file mode 100644 index 0000000000..e8dacc1360 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-member-calls/models/User.java @@ -0,0 +1,7 @@ +package models; + +public class User { + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-member-calls/services/UserService.java b/gitnexus/test/fixtures/lang-resolution/java-member-calls/services/UserService.java new file mode 100644 index 0000000000..494b5af2aa --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-member-calls/services/UserService.java @@ -0,0 +1,10 @@ +package services; + +import models.User; + +public class UserService { + public boolean processUser() { + User user = new User(); + return user.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/App.java b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/App.java new file mode 100644 index 0000000000..c3d0eeff48 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/App.java @@ -0,0 +1,12 @@ +import services.UserService; +import models.User; + +public class App { + public static void processWithService(UserService svc) { + svc.getUser().address.save(); + } + + public static void processWithUser(User user) { + user.getAddress().city.getName(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/Address.java b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/Address.java new file mode 100644 index 0000000000..b37a7f78d1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/Address.java @@ -0,0 +1,8 @@ +package models; + +public class Address { + public City city; + + public void save() { + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/City.java b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/City.java new file mode 100644 index 0000000000..c75cf7e2e7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/City.java @@ -0,0 +1,7 @@ +package models; + +public class City { + public String getName() { + return "city"; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/User.java new file mode 100644 index 0000000000..3a9355dedf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/models/User.java @@ -0,0 +1,9 @@ +package models; + +public class User { + public Address address; + + public Address getAddress() { + return this.address; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/services/UserService.java b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/services/UserService.java new file mode 100644 index 0000000000..fe18a97b0e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-mixed-chain/services/UserService.java @@ -0,0 +1,9 @@ +package services; + +import models.User; + +public class UserService { + public User getUser() { + return new User(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/app/Main.java b/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/app/Main.java new file mode 100644 index 0000000000..0853aa88bb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/app/Main.java @@ -0,0 +1,10 @@ +package com.example.app; + +import com.example.models.User; + +public class Main { + public void run() { + User user = new User(); + user.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/models/User.java new file mode 100644 index 0000000000..d404f7bbd6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/models/User.java @@ -0,0 +1,7 @@ +package com.example.models; + +public class User { + public void save() { + System.out.println("models User save"); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/other/User.java b/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/other/User.java new file mode 100644 index 0000000000..c3d4403f86 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-named-imports/com/example/other/User.java @@ -0,0 +1,7 @@ +package com.example.other; + +public class User { + public void save() { + System.out.println("other User save"); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/App.java b/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/App.java new file mode 100644 index 0000000000..0ea99662af --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/App.java @@ -0,0 +1,19 @@ +import models.User; +import models.Repo; + +public class App { + public static void processEntities() { + User user = findUser(); + Repo repo = findRepo(); + user.save(); + repo.save(); + } + + private static User findUser() { + return new User(); + } + + private static Repo findRepo() { + return new Repo(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/models/Repo.java new file mode 100644 index 0000000000..cf3712bbca --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/models/Repo.java @@ -0,0 +1,7 @@ +package models; + +public class Repo { + public boolean save() { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/models/User.java new file mode 100644 index 0000000000..e8dacc1360 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-nullable-receiver/models/User.java @@ -0,0 +1,7 @@ +package models; + +public class User { + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/App.java b/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/App.java new file mode 100644 index 0000000000..0f1c6d79c4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/App.java @@ -0,0 +1,20 @@ +import models.User; +import models.Repo; + +// Tests that Optional<User> unwraps to User in TypeEnv, +// so assignment chains from Optional-typed sources resolve correctly. +public class App { + static User findUser() { return new User(); } + static Repo findRepo() { return new Repo(); } + + static void processEntities() { + // Optional<User> declared — TypeEnv stores "User" (not "Optional") + // The alias then propagates User through the chain + java.util.Optional<User> opt = java.util.Optional.of(findUser()); + User user = opt.get(); + user.save(); + + Repo repo = findRepo(); + repo.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/models/Repo.java new file mode 100644 index 0000000000..acd3d3991a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/models/Repo.java @@ -0,0 +1,5 @@ +package models; + +public class Repo { + public void save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/models/User.java new file mode 100644 index 0000000000..4bb7299936 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-optional-receiver/models/User.java @@ -0,0 +1,5 @@ +package models; + +public class User { + public void save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/interfaces/Serializable.java b/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/interfaces/Serializable.java new file mode 100644 index 0000000000..fec500b419 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/interfaces/Serializable.java @@ -0,0 +1,5 @@ +package interfaces; + +public interface Serializable { + String serialize(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/models/BaseModel.java b/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/models/BaseModel.java new file mode 100644 index 0000000000..804771b3b2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/models/BaseModel.java @@ -0,0 +1,5 @@ +package models; + +public class BaseModel { + public boolean save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/models/User.java new file mode 100644 index 0000000000..4952c8b860 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-parent-resolution/src/models/User.java @@ -0,0 +1,7 @@ +package models; + +import interfaces.Serializable; + +public class User extends BaseModel implements Serializable { + public String serialize() { return ""; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/App.java b/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/App.java new file mode 100644 index 0000000000..493b4226a8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/App.java @@ -0,0 +1,11 @@ +import models.User; +import models.Repo; + +public class App { + public static void processEntities() { + User user = new User(); + Repo repo = new Repo(); + user.save(); + repo.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/models/Repo.java new file mode 100644 index 0000000000..cf3712bbca --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/models/Repo.java @@ -0,0 +1,7 @@ +package models; + +public class Repo { + public boolean save() { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/models/User.java new file mode 100644 index 0000000000..e8dacc1360 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-receiver-resolution/models/User.java @@ -0,0 +1,7 @@ +package models; + +public class User { + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/App.java b/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/App.java new file mode 100644 index 0000000000..135a511d4e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/App.java @@ -0,0 +1,9 @@ +import services.UserService; + +public class App { + public static void processUser() { + UserService svc = new UserService(); + var user = svc.getUser("alice"); + user.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/models/User.java new file mode 100644 index 0000000000..9d605797e3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/models/User.java @@ -0,0 +1,13 @@ +package models; + +public class User { + private String name; + + public User(String name) { + this.name = name; + } + + public boolean save() { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/services/UserService.java b/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/services/UserService.java new file mode 100644 index 0000000000..56975c53e2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-return-type-inference/services/UserService.java @@ -0,0 +1,9 @@ +package services; + +import models.User; + +public class UserService { + public User getUser(String name) { + return new User(name); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-self-this-resolution/src/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-self-this-resolution/src/models/Repo.java new file mode 100644 index 0000000000..4abcdfce8c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-self-this-resolution/src/models/Repo.java @@ -0,0 +1,5 @@ +package models; + +public class Repo { + public boolean save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-self-this-resolution/src/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-self-this-resolution/src/models/User.java new file mode 100644 index 0000000000..42bad2849b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-self-this-resolution/src/models/User.java @@ -0,0 +1,8 @@ +package models; + +public class User { + public boolean save() { return true; } + public void process() { + this.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/BaseModel.java b/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/BaseModel.java new file mode 100644 index 0000000000..804771b3b2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/BaseModel.java @@ -0,0 +1,5 @@ +package models; + +public class BaseModel { + public boolean save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/Repo.java new file mode 100644 index 0000000000..4abcdfce8c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/Repo.java @@ -0,0 +1,5 @@ +package models; + +public class Repo { + public boolean save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/User.java new file mode 100644 index 0000000000..01ab6241ca --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-super-resolution/src/models/User.java @@ -0,0 +1,8 @@ +package models; + +public class User extends BaseModel { + public boolean save() { + super.save(); + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/App.java b/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/App.java new file mode 100644 index 0000000000..1d28070fc4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/App.java @@ -0,0 +1,19 @@ +import models.User; +import models.Repo; + +public class App { + public static void processAny(Object obj) { + switch (obj) { + case User user -> user.save(); + case Repo repo -> repo.save(); + default -> {} + } + } + + public static void handleUser(Object obj) { + switch (obj) { + case User user -> user.save(); + default -> {} + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/models/Repo.java b/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/models/Repo.java new file mode 100644 index 0000000000..acd3d3991a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/models/Repo.java @@ -0,0 +1,5 @@ +package models; + +public class Repo { + public void save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/models/User.java new file mode 100644 index 0000000000..4bb7299936 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-switch-pattern/models/User.java @@ -0,0 +1,5 @@ +package models; + +public class User { + public void save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-variadic-resolution/com/example/app/Main.java b/gitnexus/test/fixtures/lang-resolution/java-variadic-resolution/com/example/app/Main.java new file mode 100644 index 0000000000..e32e3c07e2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-variadic-resolution/com/example/app/Main.java @@ -0,0 +1,10 @@ +package com.example.app; + +import com.example.util.Logger; + +public class Main { + public void run() { + Logger logger = new Logger(); + logger.record("hello", "world", "test"); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-variadic-resolution/com/example/util/Logger.java b/gitnexus/test/fixtures/lang-resolution/java-variadic-resolution/com/example/util/Logger.java new file mode 100644 index 0000000000..eebfb4c67b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-variadic-resolution/com/example/util/Logger.java @@ -0,0 +1,7 @@ +package com.example.util; + +public class Logger { + public void record(String... args) { + for (String a : args) System.out.println(a); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-write-access/App.java b/gitnexus/test/fixtures/lang-resolution/java-write-access/App.java new file mode 100644 index 0000000000..795e01a8ad --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-write-access/App.java @@ -0,0 +1,9 @@ +import models.User; +import models.Address; + +public class App { + public static void updateUser(User user) { + user.name = "Alice"; + user.address = new Address(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-write-access/models/Address.java b/gitnexus/test/fixtures/lang-resolution/java-write-access/models/Address.java new file mode 100644 index 0000000000..85e1e79a82 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-write-access/models/Address.java @@ -0,0 +1,5 @@ +package models; + +public class Address { + public String city; +} diff --git a/gitnexus/test/fixtures/lang-resolution/java-write-access/models/User.java b/gitnexus/test/fixtures/lang-resolution/java-write-access/models/User.java new file mode 100644 index 0000000000..ec750c4f97 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/java-write-access/models/User.java @@ -0,0 +1,6 @@ +package models; + +public class User { + public String name; + public Address address; +} diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/app.js b/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/app.js new file mode 100644 index 0000000000..349625a472 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/app.js @@ -0,0 +1,8 @@ +const { UserService } = require('./service'); + +function processUser() { + const svc = new UserService(); + svc.getUser().save(); +} + +module.exports = { processUser }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/repo.js b/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/repo.js new file mode 100644 index 0000000000..41ab272dfd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/repo.js @@ -0,0 +1,7 @@ +class Repo { + save() { + return true; + } +} + +module.exports = { Repo }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/service.js b/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/service.js new file mode 100644 index 0000000000..ab665e2802 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/service.js @@ -0,0 +1,12 @@ +const { User } = require('./user'); + +class UserService { + /** + * @returns {User} + */ + getUser() { + return new User(); + } +} + +module.exports = { UserService }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/user.js b/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/user.js new file mode 100644 index 0000000000..62f995fae8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-chain-call/src/user.js @@ -0,0 +1,7 @@ +class User { + save() { + return true; + } +} + +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/app.js b/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/app.js new file mode 100644 index 0000000000..ec2609dd6d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/app.js @@ -0,0 +1,11 @@ +const { User } = require('./user'); +const { Repo } = require('./repo'); + +function processEntities() { + const user = new User(); + const repo = new Repo(); + user.save(); + repo.save(); +} + +module.exports = { processEntities }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/repo.js b/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/repo.js new file mode 100644 index 0000000000..b224a3a1cb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/repo.js @@ -0,0 +1,7 @@ +class Repo { + save() { + return false; + } +} + +module.exports = { Repo }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/user.js b/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/user.js new file mode 100644 index 0000000000..62f995fae8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-constructor-type-inference/src/user.js @@ -0,0 +1,7 @@ +class User { + save() { + return true; + } +} + +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-parent-resolution/src/models/Base.js b/gitnexus/test/fixtures/lang-resolution/javascript-parent-resolution/src/models/Base.js new file mode 100644 index 0000000000..6a7bf92de9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-parent-resolution/src/models/Base.js @@ -0,0 +1,4 @@ +class BaseModel { + save() { return true; } +} +module.exports = { BaseModel }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-parent-resolution/src/models/User.js b/gitnexus/test/fixtures/lang-resolution/javascript-parent-resolution/src/models/User.js new file mode 100644 index 0000000000..cb2644d5f3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-parent-resolution/src/models/User.js @@ -0,0 +1,6 @@ +const { BaseModel } = require('./Base'); + +class User extends BaseModel { + serialize() { return ''; } +} +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-self-this-resolution/src/models/Repo.js b/gitnexus/test/fixtures/lang-resolution/javascript-self-this-resolution/src/models/Repo.js new file mode 100644 index 0000000000..41ab63ddd6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-self-this-resolution/src/models/Repo.js @@ -0,0 +1,4 @@ +class Repo { + save() { return true; } +} +module.exports = { Repo }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-self-this-resolution/src/models/User.js b/gitnexus/test/fixtures/lang-resolution/javascript-self-this-resolution/src/models/User.js new file mode 100644 index 0000000000..48f4944d68 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-self-this-resolution/src/models/User.js @@ -0,0 +1,7 @@ +class User { + save() { return true; } + process() { + this.save(); + } +} +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/Base.js b/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/Base.js new file mode 100644 index 0000000000..6a7bf92de9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/Base.js @@ -0,0 +1,4 @@ +class BaseModel { + save() { return true; } +} +module.exports = { BaseModel }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/Repo.js b/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/Repo.js new file mode 100644 index 0000000000..41ab63ddd6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/Repo.js @@ -0,0 +1,4 @@ +class Repo { + save() { return true; } +} +module.exports = { Repo }; diff --git a/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/User.js b/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/User.js new file mode 100644 index 0000000000..79efca509b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/javascript-super-resolution/src/models/User.js @@ -0,0 +1,9 @@ +const { BaseModel } = require('./Base'); + +class User extends BaseModel { + save() { + super.save(); + return true; + } +} +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-field-types/models.js b/gitnexus/test/fixtures/lang-resolution/js-field-types/models.js new file mode 100644 index 0000000000..4d9d45fa47 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-field-types/models.js @@ -0,0 +1,26 @@ +class Address { + city = ''; + + save() { + // persist address + } +} + +class User { + name = ''; + address = new Address(); + + greet() { + return this.name; + } +} + +class Config { + static DEFAULT = new Config(); + + validate() { + return true; + } +} + +module.exports = { Address, User, Config }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-field-types/service.js b/gitnexus/test/fixtures/lang-resolution/js-field-types/service.js new file mode 100644 index 0000000000..9f94946215 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-field-types/service.js @@ -0,0 +1,9 @@ +const { User, Config } = require('./models'); + +function processUser(user) { + user.address.save(); +} + +function validateConfig() { + Config.DEFAULT.validate(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/app.js b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/app.js new file mode 100644 index 0000000000..01b8de1432 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/app.js @@ -0,0 +1,26 @@ +const { User } = require('./user'); +const { Repo } = require('./repo'); + +/** + * @returns {Promise<User>} + */ +async function fetchUser(name) { + return new User(name); +} + +/** + * @returns {Promise<Repo>} + */ +async function fetchRepo(path) { + return new Repo(path); +} + +async function processUser() { + const user = await fetchUser('alice'); + user.save(); +} + +async function processRepo() { + const repo = await fetchRepo('/data'); + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/repo.js b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/repo.js new file mode 100644 index 0000000000..a85e9c39a0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/repo.js @@ -0,0 +1,11 @@ +class Repo { + constructor(path) { + this.path = path; + } + + save() { + return true; + } +} + +module.exports = { Repo }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/user.js b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/user.js new file mode 100644 index 0000000000..7f19a622d0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-async-return-type/user.js @@ -0,0 +1,11 @@ +class User { + constructor(name) { + this.name = name; + } + + save() { + return true; + } +} + +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-jsdoc-qualified-return-type/app.js b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-qualified-return-type/app.js new file mode 100644 index 0000000000..8b1473dabe --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-qualified-return-type/app.js @@ -0,0 +1,13 @@ +const { User } = require('./user'); + +/** + * @returns {Promise<models.User>} + */ +async function fetchUser(name) { + return new User(name); +} + +async function processUser() { + const user = await fetchUser('alice'); + user.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/js-jsdoc-qualified-return-type/user.js b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-qualified-return-type/user.js new file mode 100644 index 0000000000..7f19a622d0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-qualified-return-type/user.js @@ -0,0 +1,11 @@ +class User { + constructor(name) { + this.name = name; + } + + save() { + return true; + } +} + +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/app.js b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/app.js new file mode 100644 index 0000000000..fc60b05ca8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/app.js @@ -0,0 +1,40 @@ +const { User } = require('./user'); +const { Repo } = require('./repo'); + +/** + * @returns {User} + */ +function getUser(name) { + return new User(name); +} + +/** + * @returns {Repo} + */ +function getRepo(path) { + return new Repo(path); +} + +function processUser() { + const user = getUser('alice'); + user.save(); +} + +function processRepo() { + const repo = getRepo('/data'); + repo.save(); +} + +/** + * @param {User} user the user to handle + */ +function handleUser(user) { + user.save(); +} + +/** + * @param {Repo} repo the repo to handle + */ +function handleRepo(repo) { + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/repo.js b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/repo.js new file mode 100644 index 0000000000..a85e9c39a0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/repo.js @@ -0,0 +1,11 @@ +class Repo { + constructor(path) { + this.path = path; + } + + save() { + return true; + } +} + +module.exports = { Repo }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/user.js b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/user.js new file mode 100644 index 0000000000..7f19a622d0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-jsdoc-return-type/user.js @@ -0,0 +1,11 @@ +class User { + constructor(name) { + this.name = name; + } + + save() { + return true; + } +} + +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/app.js b/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/app.js new file mode 100644 index 0000000000..f9e08c969a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/app.js @@ -0,0 +1,11 @@ +const { User } = require('./user'); +const { Repo } = require('./repo'); + +/** + * @param {User | null} user + * @param {Repo | null} repo + */ +function processEntities(user, repo) { + if (user) user.save(); + if (repo) repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/repo.js b/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/repo.js new file mode 100644 index 0000000000..41ab63ddd6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/repo.js @@ -0,0 +1,4 @@ +class Repo { + save() { return true; } +} +module.exports = { Repo }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/user.js b/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/user.js new file mode 100644 index 0000000000..e11c8bc1a2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-nullable-receiver/src/user.js @@ -0,0 +1,4 @@ +class User { + save() { return true; } +} +module.exports = { User }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-write-access/models.js b/gitnexus/test/fixtures/lang-resolution/js-write-access/models.js new file mode 100644 index 0000000000..ac80db7e1e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-write-access/models.js @@ -0,0 +1,10 @@ +class Address { + city = ''; +} + +class User { + name = ''; + address = null; +} + +module.exports = { Address, User }; diff --git a/gitnexus/test/fixtures/lang-resolution/js-write-access/service.js b/gitnexus/test/fixtures/lang-resolution/js-write-access/service.js new file mode 100644 index 0000000000..f3e681179f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/js-write-access/service.js @@ -0,0 +1,7 @@ +const { User, Address } = require('./models'); + +function updateUser() { + const user = new User(); + user.name = "Alice"; + user.address = new Address(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-alias-imports/app/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-alias-imports/app/App.kt new file mode 100644 index 0000000000..83241e19c4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-alias-imports/app/App.kt @@ -0,0 +1,11 @@ +package app + +import models.User as U +import models.Repo as R + +fun main() { + val u = U("alice") + val r = R("https://example.com") + u.save() + r.persist() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-alias-imports/models/Models.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-alias-imports/models/Models.kt new file mode 100644 index 0000000000..3f89795886 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-alias-imports/models/Models.kt @@ -0,0 +1,9 @@ +package models + +class User(val name: String) { + fun save(): Boolean = true +} + +class Repo(val url: String) { + fun persist(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/models/Handler.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/models/Handler.kt new file mode 100644 index 0000000000..c1525f253d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/models/Handler.kt @@ -0,0 +1,5 @@ +package models + +open class Handler { + open fun handle() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/models/Runnable.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/models/Runnable.kt new file mode 100644 index 0000000000..0378321c93 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/models/Runnable.kt @@ -0,0 +1,5 @@ +package models + +interface Runnable { + fun run() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/other/Handler.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/other/Handler.kt new file mode 100644 index 0000000000..a474c85811 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/other/Handler.kt @@ -0,0 +1,5 @@ +package other + +open class Handler { + open fun process() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/other/Runnable.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/other/Runnable.kt new file mode 100644 index 0000000000..33d135ea67 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/other/Runnable.kt @@ -0,0 +1,5 @@ +package other + +interface Runnable { + fun execute() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/services/UserHandler.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/services/UserHandler.kt new file mode 100644 index 0000000000..67cfad116d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-ambiguous/services/UserHandler.kt @@ -0,0 +1,8 @@ +package services + +import models.Handler +import models.Runnable + +class UserHandler : Handler(), Runnable { + override fun run() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/App.kt new file mode 100644 index 0000000000..d7cb22762a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/App.kt @@ -0,0 +1,12 @@ +fun getUser(): User = User() +fun getRepo(): Repo = Repo() + +fun processEntities() { + val u: User = getUser() + val alias = u + alias.save() + + val r: Repo = getRepo() + val rAlias = r + rAlias.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/models/Repo.kt new file mode 100644 index 0000000000..2a2f09bf5e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/models/Repo.kt @@ -0,0 +1,3 @@ +class Repo { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/models/User.kt new file mode 100644 index 0000000000..e5d4114ba4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-assignment-chain/models/User.kt @@ -0,0 +1,3 @@ +class User { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-calls/services/UserService.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-calls/services/UserService.kt new file mode 100644 index 0000000000..3db52664c8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-calls/services/UserService.kt @@ -0,0 +1,10 @@ +package services + +import util.OneArg.writeAudit +import util.ZeroArg.writeAudit + +class UserService { + fun processUser() { + writeAudit("hello") + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-calls/util/OneArg.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-calls/util/OneArg.kt new file mode 100644 index 0000000000..be0c8351f9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-calls/util/OneArg.kt @@ -0,0 +1,7 @@ +package util + +object OneArg { + fun writeAudit(message: String): String { + return message + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-calls/util/ZeroArg.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-calls/util/ZeroArg.kt new file mode 100644 index 0000000000..736c1ac6b6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-calls/util/ZeroArg.kt @@ -0,0 +1,7 @@ +package util + +object ZeroArg { + fun writeAudit(): String { + return "zero" + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/App.kt new file mode 100644 index 0000000000..a15d839a63 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/App.kt @@ -0,0 +1,7 @@ +import models.User +import services.UserService + +fun processUser() { + val svc = UserService() + svc.getUser().save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/Repo.kt new file mode 100644 index 0000000000..8e31ab2a04 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/User.kt new file mode 100644 index 0000000000..494376e42e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/User.kt @@ -0,0 +1,5 @@ +package models + +class User { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/UserService.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/UserService.kt new file mode 100644 index 0000000000..e091d77a9b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-chain-call/src/UserService.kt @@ -0,0 +1,9 @@ +package services + +import models.User + +class UserService { + fun getUser(): User { + return User() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/App.kt new file mode 100644 index 0000000000..dae685000a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/App.kt @@ -0,0 +1,14 @@ +// Assignment chain with typed parameter propagation. +// Tests that extractKotlinPendingAssignment handles val alias = u +// where u comes from an explicit typed declaration. +fun processUser() { + val u: User = User() + val alias = u + alias.save() +} + +fun processRepo() { + val r: Repo = Repo() + val alias = r + alias.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/models/Repo.kt new file mode 100644 index 0000000000..2a2f09bf5e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/models/Repo.kt @@ -0,0 +1,3 @@ +class Repo { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/models/User.kt new file mode 100644 index 0000000000..e5d4114ba4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-class-method-chain/models/User.kt @@ -0,0 +1,3 @@ +class User { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-calls/app/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-calls/app/App.kt new file mode 100644 index 0000000000..ced26b2178 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-calls/app/App.kt @@ -0,0 +1,8 @@ +package app + +import models.User + +fun main() { + val user = User("alice") + user.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-calls/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-calls/models/User.kt new file mode 100644 index 0000000000..7b3c396104 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-calls/models/User.kt @@ -0,0 +1,5 @@ +package models + +class User(val name: String) { + fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/models/Repo.kt new file mode 100644 index 0000000000..c337e368c1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/models/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo(val dbName: String) { + fun save(): Boolean = false +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/models/User.kt new file mode 100644 index 0000000000..7b3c396104 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/models/User.kt @@ -0,0 +1,5 @@ +package models + +class User(val name: String) { + fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/services/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/services/App.kt new file mode 100644 index 0000000000..532650adfb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-constructor-type-inference/services/App.kt @@ -0,0 +1,11 @@ +package services + +import models.User +import models.Repo + +fun processEntities() { + val user = User("alice") + val repo = Repo("maindb") + user.save() + repo.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-data-class-fields/Models.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-data-class-fields/Models.kt new file mode 100644 index 0000000000..837c236333 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-data-class-fields/Models.kt @@ -0,0 +1,13 @@ +class Address { + var city: String = "" + + fun save() { + // persist address + } +} + +data class User( + val name: String, + val address: Address, + val age: Int +) diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-data-class-fields/Service.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-data-class-fields/Service.kt new file mode 100644 index 0000000000..706294126f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-data-class-fields/Service.kt @@ -0,0 +1,4 @@ +fun processUser(user: User) { + // Field-access chain: user.address → Address, then .save() → Address#save + user.address.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-deep-field-chain/Models.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-deep-field-chain/Models.kt new file mode 100644 index 0000000000..44e658a3bd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-deep-field-chain/Models.kt @@ -0,0 +1,25 @@ +class City { + var zipCode: String = "" + + fun getName(): String { + return "city" + } +} + +class Address { + var city: City = City() + var street: String = "" + + fun save() { + // persist address + } +} + +class User { + var name: String = "" + var address: Address = Address() + + fun greet(): String { + return name + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-deep-field-chain/Service.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-deep-field-chain/Service.kt new file mode 100644 index 0000000000..b07cdc865d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-deep-field-chain/Service.kt @@ -0,0 +1,7 @@ +fun processUser(user: User) { + // 2-level chain: user.address → Address, then .save() → Address#save + user.address.save() + + // 3-level chain: user.address → Address, .city → City, .getName() → City#getName + user.address.city.getName() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-field-types/Models.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-field-types/Models.kt new file mode 100644 index 0000000000..de11904256 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-field-types/Models.kt @@ -0,0 +1,16 @@ +class Address { + var city: String = "" + + fun save() { + // persist address + } +} + +class User { + var name: String = "" + var address: Address = Address() + + fun greet(): String { + return name + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-field-types/Service.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-field-types/Service.kt new file mode 100644 index 0000000000..706294126f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-field-types/Service.kt @@ -0,0 +1,4 @@ +fun processUser(user: User) { + // Field-access chain: user.address → Address, then .save() → Address#save + user.address.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/Main.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/Main.kt new file mode 100644 index 0000000000..7637491529 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/Main.kt @@ -0,0 +1,16 @@ +import models.getUsers +import models.getRepos + +fun processUsers() { + for (user in getUsers()) { + user.save() + } +} + +fun processRepos() { + for (repo in getRepos()) { + repo.save() + } +} + +fun main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/models/Repo.kt new file mode 100644 index 0000000000..6e8ab9698c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/models/Repo.kt @@ -0,0 +1,9 @@ +package models + +class Repo(val name: String) { + fun save() {} +} + +fun getRepos(): List<Repo> { + return listOf(Repo("main")) +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/models/User.kt new file mode 100644 index 0000000000..82e54c8e91 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach-call-expr/models/User.kt @@ -0,0 +1,9 @@ +package models + +class User(val name: String) { + fun save() {} +} + +fun getUsers(): List<User> { + return listOf(User("alice")) +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/App.kt new file mode 100644 index 0000000000..02896161f4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/App.kt @@ -0,0 +1,16 @@ +package app + +import models.User +import models.Repo + +fun processUsers(users: List<User>) { + for (user: User in users) { + user.save() + } +} + +fun processRepos(repos: List<Repo>) { + for (repo: Repo in repos) { + repo.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/models/Repo.kt new file mode 100644 index 0000000000..8e31ab2a04 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/models/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/models/User.kt new file mode 100644 index 0000000000..494376e42e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-foreach/models/User.kt @@ -0,0 +1,5 @@ +package models + +class User { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/BaseModel.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/BaseModel.kt new file mode 100644 index 0000000000..7c372216c3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/BaseModel.kt @@ -0,0 +1,5 @@ +package models + +open class BaseModel<T> { + open fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/Repo.kt new file mode 100644 index 0000000000..97c8fdeb5d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo { + fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/User.kt new file mode 100644 index 0000000000..44327de3c9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-generic-parent-resolution/models/User.kt @@ -0,0 +1,8 @@ +package models + +class User : BaseModel<String>() { + override fun save(): Boolean { + super.save() + return true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/interfaces/Serializable.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/interfaces/Serializable.kt new file mode 100644 index 0000000000..f6fd0fe38e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/interfaces/Serializable.kt @@ -0,0 +1,5 @@ +package interfaces + +interface Serializable { + fun serialize(): String +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/interfaces/Validatable.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/interfaces/Validatable.kt new file mode 100644 index 0000000000..0e0f5fcc4e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/interfaces/Validatable.kt @@ -0,0 +1,5 @@ +package interfaces + +interface Validatable { + fun validate(): Boolean +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/models/BaseModel.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/models/BaseModel.kt new file mode 100644 index 0000000000..9ef344c322 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/models/BaseModel.kt @@ -0,0 +1,7 @@ +package models + +abstract class BaseModel { + fun save() { + // persist to storage + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/models/User.kt new file mode 100644 index 0000000000..306fb56292 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/models/User.kt @@ -0,0 +1,10 @@ +package models + +import interfaces.Serializable +import interfaces.Validatable + +data class User(val name: String) : BaseModel(), Serializable, Validatable { + override fun serialize(): String = name + + override fun validate(): Boolean = name.isNotEmpty() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/services/UserService.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/services/UserService.kt new file mode 100644 index 0000000000..9795c6027b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-heritage/services/UserService.kt @@ -0,0 +1,11 @@ +package services + +import models.User +import interfaces.Serializable + +class UserService { + fun processUser(user: User) { + user.validate() + user.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-local-shadow/src/main/kotlin/app/Main.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-local-shadow/src/main/kotlin/app/Main.kt new file mode 100644 index 0000000000..237ad4cc45 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-local-shadow/src/main/kotlin/app/Main.kt @@ -0,0 +1,12 @@ +package app + +import utils.save + +// Local function shadows imported save +fun save(data: String) { + println("local save: $data") +} + +fun run() { + save("test") +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-local-shadow/src/main/kotlin/utils/Logger.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-local-shadow/src/main/kotlin/utils/Logger.kt new file mode 100644 index 0000000000..13984419f1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-local-shadow/src/main/kotlin/utils/Logger.kt @@ -0,0 +1,5 @@ +package utils + +fun save(data: String) { + println("utils save: $data") +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/App.kt new file mode 100644 index 0000000000..08be0d5e11 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/App.kt @@ -0,0 +1,29 @@ +fun processValues(data: HashMap<String, User>) { + for (user in data.values) { + user.save() + } +} + +fun processKeys(data: HashMap<User, Repo>) { + for (user in data.keys) { + user.save() + } +} + +fun processMutableMapValues(data: MutableMap<String, Repo>) { + for (repo in data.values) { + repo.save() + } +} + +fun processList(users: List<User>) { + for (user in users) { + user.save() + } +} + +fun processSet(repos: Set<Repo>) { + for (repo in repos) { + repo.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/Repo.kt new file mode 100644 index 0000000000..0c3c2725f3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/Repo.kt @@ -0,0 +1,3 @@ +class Repo(val name: String) { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/User.kt new file mode 100644 index 0000000000..4149527087 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-map-keys-values/src/User.kt @@ -0,0 +1,3 @@ +class User(val name: String) { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-member-calls/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-member-calls/models/User.kt new file mode 100644 index 0000000000..e606280377 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-member-calls/models/User.kt @@ -0,0 +1,7 @@ +package models + +class User { + fun save(): Boolean { + return true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-member-calls/services/UserService.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-member-calls/services/UserService.kt new file mode 100644 index 0000000000..6f5a885b36 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-member-calls/services/UserService.kt @@ -0,0 +1,10 @@ +package services + +import models.User + +class UserService { + fun processUser(): Boolean { + val user = User() + return user.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/models/Repo.kt new file mode 100644 index 0000000000..c337e368c1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/models/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo(val dbName: String) { + fun save(): Boolean = false +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/models/User.kt new file mode 100644 index 0000000000..7b3c396104 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/models/User.kt @@ -0,0 +1,5 @@ +package models + +class User(val name: String) { + fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/services/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/services/App.kt new file mode 100644 index 0000000000..63a2e97d1d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-nullable-receiver/services/App.kt @@ -0,0 +1,13 @@ +package services + +import models.User +import models.Repo + +fun processEntities() { + val user: User? = User("alice") + val repo: Repo? = Repo("maindb") + + // Safe calls on nullable receivers — should disambiguate via unwrapped type + user?.save() + repo?.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/BaseModel.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/BaseModel.kt new file mode 100644 index 0000000000..14ae906145 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/BaseModel.kt @@ -0,0 +1,5 @@ +package models + +open class BaseModel { + fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/Serializable.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/Serializable.kt new file mode 100644 index 0000000000..1cc1406e61 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/Serializable.kt @@ -0,0 +1,5 @@ +package models + +interface Serializable { + fun serialize(): String +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/User.kt new file mode 100644 index 0000000000..4955fef800 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-parent-resolution/models/User.kt @@ -0,0 +1,5 @@ +package models + +class User : BaseModel(), Serializable { + override fun serialize(): String = "" +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/models/Repo.kt new file mode 100644 index 0000000000..2d89c28155 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/models/Repo.kt @@ -0,0 +1,7 @@ +package models + +class Repo { + fun save(): Boolean { + return false + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/models/User.kt new file mode 100644 index 0000000000..e606280377 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/models/User.kt @@ -0,0 +1,7 @@ +package models + +class User { + fun save(): Boolean { + return true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/services/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/services/App.kt new file mode 100644 index 0000000000..40cdee0808 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-receiver-resolution/services/App.kt @@ -0,0 +1,13 @@ +package services + +import models.User +import models.Repo + +class AppService { + fun processEntities() { + val user: User = User() + val repo: Repo = Repo() + user.save() + repo.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/models/Repo.kt new file mode 100644 index 0000000000..23159e2cc1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/models/Repo.kt @@ -0,0 +1,9 @@ +package models + +class Repo(val name: String) { + fun save() {} +} + +fun getRepo(name: String): Repo { + return Repo(name) +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/models/User.kt new file mode 100644 index 0000000000..e3a3e71eca --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/models/User.kt @@ -0,0 +1,9 @@ +package models + +class User(val name: String) { + fun save() {} +} + +fun getUser(name: String): User { + return User(name) +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/services/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/services/App.kt new file mode 100644 index 0000000000..ecd4bb264c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-return-type/services/App.kt @@ -0,0 +1,14 @@ +package services + +import models.getUser +import models.getRepo + +fun processUser() { + val user = getUser("alice") + user.save() +} + +fun processRepo() { + val repo = getRepo("main") + repo.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/AppConfig.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/AppConfig.kt new file mode 100644 index 0000000000..ac40d9ded4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/AppConfig.kt @@ -0,0 +1,8 @@ +package models + +object AppConfig { + fun init(): Boolean = true + fun setup() { + this.init() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/Repo.kt new file mode 100644 index 0000000000..97c8fdeb5d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo { + fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/User.kt new file mode 100644 index 0000000000..0e1176a69d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-self-this-resolution/models/User.kt @@ -0,0 +1,8 @@ +package models + +class User { + fun save(): Boolean = true + fun process() { + this.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/BaseModel.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/BaseModel.kt new file mode 100644 index 0000000000..9e71d30437 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/BaseModel.kt @@ -0,0 +1,5 @@ +package models + +open class BaseModel { + open fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/Repo.kt new file mode 100644 index 0000000000..97c8fdeb5d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo { + fun save(): Boolean = true +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/User.kt new file mode 100644 index 0000000000..aba049296d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-super-resolution/models/User.kt @@ -0,0 +1,8 @@ +package models + +class User : BaseModel() { + override fun save(): Boolean { + super.save() + return true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/app.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/app.kt new file mode 100644 index 0000000000..fd31c8bbc9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/app.kt @@ -0,0 +1,16 @@ +package app + +import models.User +import models.Repo + +fun processUsers(users: List<User>) { + for (user in users) { + user.save() + } +} + +fun processRepos(repos: List<Repo>) { + for (repo in repos) { + repo.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/models/Repo.kt new file mode 100644 index 0000000000..8e31ab2a04 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/models/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/models/User.kt new file mode 100644 index 0000000000..494376e42e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-var-foreach/models/User.kt @@ -0,0 +1,5 @@ +package models + +class User { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-variadic-resolution/app/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-variadic-resolution/app/App.kt new file mode 100644 index 0000000000..884caf3654 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-variadic-resolution/app/App.kt @@ -0,0 +1,7 @@ +package app + +import util.logEntry + +fun main() { + logEntry("hello", "world", "test") +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-variadic-resolution/util/Logger.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-variadic-resolution/util/Logger.kt new file mode 100644 index 0000000000..b8a558f88d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-variadic-resolution/util/Logger.kt @@ -0,0 +1,5 @@ +package util + +fun logEntry(vararg messages: String) { + messages.forEach { println(it) } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/App.kt new file mode 100644 index 0000000000..8a9929d997 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/App.kt @@ -0,0 +1,34 @@ +import models.User +import models.Repo +import models.Admin + +// Three-arm when: each arm should resolve obj to its narrowed type +fun processThreeArms(obj: Any) { + when (obj) { + is User -> obj.save() + is Repo -> obj.save() + is Admin -> obj.save() + } +} + +// Multiple method calls within a single when arm +fun processMultiCall(obj: Any) { + when (obj) { + is User -> { + obj.validate() + obj.save() + } + is Repo -> { + obj.validate() + obj.save() + } + } +} + +// when with else branch — else should NOT narrow the type +fun processWithElse(obj: Any) { + when (obj) { + is User -> obj.save() + else -> println(obj) + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/Admin.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/Admin.kt new file mode 100644 index 0000000000..75cf378763 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/Admin.kt @@ -0,0 +1,5 @@ +package models + +class Admin { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/Repo.kt new file mode 100644 index 0000000000..ec37f1419f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/Repo.kt @@ -0,0 +1,6 @@ +package models + +class Repo { + fun save() {} + fun validate() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/User.kt new file mode 100644 index 0000000000..bba8106c27 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-when-complex/models/User.kt @@ -0,0 +1,6 @@ +package models + +class User { + fun save() {} + fun validate() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/App.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/App.kt new file mode 100644 index 0000000000..572a601c8f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/App.kt @@ -0,0 +1,15 @@ +import models.User +import models.Repo + +fun processAny(obj: Any) { + when (obj) { + is User -> obj.save() + is Repo -> obj.save() + } +} + +fun handleUser(obj: Any) { + when (obj) { + is User -> obj.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/models/Repo.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/models/Repo.kt new file mode 100644 index 0000000000..8e31ab2a04 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/models/Repo.kt @@ -0,0 +1,5 @@ +package models + +class Repo { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/models/User.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/models/User.kt new file mode 100644 index 0000000000..494376e42e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-when-pattern/models/User.kt @@ -0,0 +1,5 @@ +package models + +class User { + fun save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-write-access/Models.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-write-access/Models.kt new file mode 100644 index 0000000000..f55b00f80f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-write-access/Models.kt @@ -0,0 +1,9 @@ +class Address { + var city: String = "" +} + +class User { + var name: String = "" + var address: Address = Address() + var score: Int = 0 +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-write-access/Service.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-write-access/Service.kt new file mode 100644 index 0000000000..2b486a03bf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-write-access/Service.kt @@ -0,0 +1,6 @@ +fun updateUser(user: User) { + user.name = "Alice" + user.address = Address() + // Compound assignment — tree-sitter-kotlin uses `assignment` node for both + user.score += 10 +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Models/Repo.php new file mode 100644 index 0000000000..3c4e3a4d6f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Models/Repo.php @@ -0,0 +1,14 @@ +<?php +namespace App\Models; + +class Repo { + public string $url; + + public function __construct(string $url) { + $this->url = $url; + } + + public function persist(): bool { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Models/User.php new file mode 100644 index 0000000000..3e6ff1179e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Models/User.php @@ -0,0 +1,14 @@ +<?php +namespace App\Models; + +class User { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): bool { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Services/Main.php b/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Services/Main.php new file mode 100644 index 0000000000..982bdb8eb6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-alias-imports/app/Services/Main.php @@ -0,0 +1,14 @@ +<?php +namespace App\Services; + +use App\Models\User as U; +use App\Models\Repo as R; + +class Main { + public function run(): void { + $u = new U("alice"); + $r = new R("https://example.com"); + $u->save(); + $r->persist(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-alias-imports/composer.json b/gitnexus/test/fixtures/lang-resolution/php-alias-imports/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-alias-imports/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Models/Dispatchable.php b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Models/Dispatchable.php new file mode 100644 index 0000000000..6075b12553 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Models/Dispatchable.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Models; + +interface Dispatchable +{ + public function dispatch(): void; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Models/Handler.php b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Models/Handler.php new file mode 100644 index 0000000000..bfb6946e72 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Models/Handler.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Models; + +class Handler +{ + public function handle(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Other/Dispatchable.php b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Other/Dispatchable.php new file mode 100644 index 0000000000..576ffaa305 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Other/Dispatchable.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Other; + +interface Dispatchable +{ + public function queue(): void; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Other/Handler.php b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Other/Handler.php new file mode 100644 index 0000000000..f8942bcb25 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Other/Handler.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Other; + +class Handler +{ + public function process(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Services/UserHandler.php b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Services/UserHandler.php new file mode 100644 index 0000000000..19dbf1ab47 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/app/Services/UserHandler.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Services; + +use App\Models\Handler; +use App\Models\Dispatchable; + +class UserHandler extends Handler implements Dispatchable +{ + public function dispatch(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-ambiguous/composer.json b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-ambiguous/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/app/Contracts/Loggable.php b/gitnexus/test/fixtures/lang-resolution/php-app/app/Contracts/Loggable.php new file mode 100644 index 0000000000..430dd4ad6f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/app/Contracts/Loggable.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Contracts; + +interface Loggable +{ + public function log(string $message): void; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/app/Contracts/Repository.php b/gitnexus/test/fixtures/lang-resolution/php-app/app/Contracts/Repository.php new file mode 100644 index 0000000000..1fea19d244 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/app/Contracts/Repository.php @@ -0,0 +1,9 @@ +<?php + +namespace App\Contracts; + +interface Repository +{ + public function find(int $id): mixed; + public function save(mixed $entity): void; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/app/Enums/UserRole.php b/gitnexus/test/fixtures/lang-resolution/php-app/app/Enums/UserRole.php new file mode 100644 index 0000000000..31c9429948 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/app/Enums/UserRole.php @@ -0,0 +1,19 @@ +<?php + +namespace App\Enums; + +enum UserRole: string +{ + case Admin = 'admin'; + case Editor = 'editor'; + case Viewer = 'viewer'; + + public function label(): string + { + return match($this) { + self::Admin => 'Administrator', + self::Editor => 'Editor', + self::Viewer => 'Viewer', + }; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/app/Models/BaseModel.php b/gitnexus/test/fixtures/lang-resolution/php-app/app/Models/BaseModel.php new file mode 100644 index 0000000000..24ce34fdf2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/app/Models/BaseModel.php @@ -0,0 +1,23 @@ +<?php + +namespace App\Models; + +use App\Contracts\Loggable; +use App\Traits\HasTimestamps; + +abstract class BaseModel implements Loggable +{ + use HasTimestamps; + + protected int $id; + + public function getId(): int + { + return $this->id; + } + + public function log(string $message): void + { + error_log($message); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-app/app/Models/User.php new file mode 100644 index 0000000000..531df4cd60 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/app/Models/User.php @@ -0,0 +1,29 @@ +<?php + +namespace App\Models; + +use App\Traits\SoftDeletes; + +class User extends BaseModel +{ + use SoftDeletes; + + private string $name; + private string $email; + + public function __construct(string $name, string $email) + { + $this->name = $name; + $this->email = $email; + } + + public function getName(): string + { + return $this->name; + } + + public function getEmail(): string + { + return $this->email; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/app/Services/UserService.php b/gitnexus/test/fixtures/lang-resolution/php-app/app/Services/UserService.php new file mode 100644 index 0000000000..5ad074596b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/app/Services/UserService.php @@ -0,0 +1,38 @@ +<?php + +namespace App\Services; + +use App\Contracts\Repository; +use App\Models\User; +use App\Enums\UserRole; + +class UserService implements Repository +{ + private array $users = []; + + public function find(int $id): ?User + { + return $this->users[$id] ?? null; + } + + public function save(mixed $entity): void + { + $this->users[$entity->getId()] = $entity; + } + + public function createUser(string $name, string $email): User + { + $user = new User($name, $email); + $this->save($user); + $user->log('User created: ' . $name); + $user?->touch(); + $defaultRole = UserRole::Viewer; + $label = $defaultRole->label(); + return $user; + } + + public static function instance(): self + { + return new self(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/app/Traits/HasTimestamps.php b/gitnexus/test/fixtures/lang-resolution/php-app/app/Traits/HasTimestamps.php new file mode 100644 index 0000000000..018a404eb8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/app/Traits/HasTimestamps.php @@ -0,0 +1,13 @@ +<?php + +namespace App\Traits; + +trait HasTimestamps +{ + protected string $status = 'active'; + + public function touch(): void + { + $this->updatedAt = new \DateTimeImmutable(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/app/Traits/SoftDeletes.php b/gitnexus/test/fixtures/lang-resolution/php-app/app/Traits/SoftDeletes.php new file mode 100644 index 0000000000..bf5563e12c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/app/Traits/SoftDeletes.php @@ -0,0 +1,18 @@ +<?php + +namespace App\Traits; + +trait SoftDeletes +{ + protected string $status = 'active'; + + public function softDelete(): void + { + $this->deletedAt = new \DateTimeImmutable(); + } + + public function restore(): void + { + $this->deletedAt = null; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-app/composer.json b/gitnexus/test/fixtures/lang-resolution/php-app/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-app/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Models/Repo.php new file mode 100644 index 0000000000..ba3ee4317c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Models/Repo.php @@ -0,0 +1,8 @@ +<?php +namespace App\Models; + +class Repo { + public function save(): bool { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Models/User.php new file mode 100644 index 0000000000..4675122882 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Models/User.php @@ -0,0 +1,8 @@ +<?php +namespace App\Models; + +class User { + public function save(): bool { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Services/AppService.php b/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Services/AppService.php new file mode 100644 index 0000000000..1bd2d285a4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/app/Services/AppService.php @@ -0,0 +1,15 @@ +<?php +namespace App\Services; + +use App\Models\User; +use App\Models\Repo; + +class AppService { + public function process(User $user, Repo $repo): void { + $alias = $user; + $alias->save(); + + $rAlias = $repo; + $rAlias->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/composer.json b/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/composer.json new file mode 100644 index 0000000000..f36c8cd0ce --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-assignment-chain/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-calls/app/Services/UserService.php b/gitnexus/test/fixtures/lang-resolution/php-calls/app/Services/UserService.php new file mode 100644 index 0000000000..fa0a1b8bea --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-calls/app/Services/UserService.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Services; + +use function App\Utils\OneArg\log; +use function App\Utils\ZeroArg\log as zero_log; + +function create_user(): string +{ + return write_audit('hello'); +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-calls/app/Utils/OneArg/log.php b/gitnexus/test/fixtures/lang-resolution/php-calls/app/Utils/OneArg/log.php new file mode 100644 index 0000000000..3ccafbf22c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-calls/app/Utils/OneArg/log.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Utils\OneArg; + +function write_audit(string $message): string +{ + return $message; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-calls/app/Utils/ZeroArg/log.php b/gitnexus/test/fixtures/lang-resolution/php-calls/app/Utils/ZeroArg/log.php new file mode 100644 index 0000000000..c78e7a0ec0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-calls/app/Utils/ZeroArg/log.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Utils\ZeroArg; + +function write_audit(): string +{ + return 'zero'; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-calls/composer.json b/gitnexus/test/fixtures/lang-resolution/php-calls/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-calls/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-constructor-calls/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-constructor-calls/Models/User.php new file mode 100644 index 0000000000..e251967b69 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-constructor-calls/Models/User.php @@ -0,0 +1,15 @@ +<?php + +namespace Models; + +class User { + private string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): bool { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-constructor-calls/app.php b/gitnexus/test/fixtures/lang-resolution/php-constructor-calls/app.php new file mode 100644 index 0000000000..2265959019 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-constructor-calls/app.php @@ -0,0 +1,8 @@ +<?php + +use Models\User; + +function processUser(string $name): void { + $user = new User($name); + $user->save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-constructor-promotion-fields/Models.php b/gitnexus/test/fixtures/lang-resolution/php-constructor-promotion-fields/Models.php new file mode 100644 index 0000000000..03eebc7b27 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-constructor-promotion-fields/Models.php @@ -0,0 +1,20 @@ +<?php + +class Address { + public string $city; + + public function save(): void { + // persist address + } +} + +class User { + public function __construct( + public string $name, + public Address $address, + ) {} + + public function greet(): string { + return $this->name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-constructor-promotion-fields/Service.php b/gitnexus/test/fixtures/lang-resolution/php-constructor-promotion-fields/Service.php new file mode 100644 index 0000000000..5744b4da74 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-constructor-promotion-fields/Service.php @@ -0,0 +1,8 @@ +<?php + +class Service { + public function processUser(User $user): void { + // Field-access chain: $user->address → Address, then ->save() → Address#save + $user->address->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Models/Repo.php new file mode 100644 index 0000000000..d3670e2f51 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Models/Repo.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Models; + +class Repo +{ + public function save(): bool + { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Models/User.php new file mode 100644 index 0000000000..b43d560830 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Models/User.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Models; + +class User +{ + public function save(): bool + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Services/AppService.php b/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Services/AppService.php new file mode 100644 index 0000000000..6d4ceced2f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/app/Services/AppService.php @@ -0,0 +1,17 @@ +<?php + +namespace App\Services; + +use App\Models\User; +use App\Models\Repo; + +class AppService +{ + public function processEntities(): void + { + $user = new User(); + $repo = new Repo(); + $user->save(); + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/composer.json b/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-constructor-type-inference/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-deep-field-chain/Models.php b/gitnexus/test/fixtures/lang-resolution/php-deep-field-chain/Models.php new file mode 100644 index 0000000000..1a91ced7a7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-deep-field-chain/Models.php @@ -0,0 +1,34 @@ +<?php + +class City { + /** @var string */ + public string $zipCode; + + public function getName(): string { + return "city"; + } +} + +class Address { + /** @var City */ + public City $city; + + /** @var string */ + public string $street; + + public function save(): void { + // persist address + } +} + +class User { + /** @var string */ + public string $name; + + /** @var Address */ + public Address $address; + + public function greet(): string { + return $this->name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-deep-field-chain/Service.php b/gitnexus/test/fixtures/lang-resolution/php-deep-field-chain/Service.php new file mode 100644 index 0000000000..05cd4b0171 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-deep-field-chain/Service.php @@ -0,0 +1,11 @@ +<?php + +class Service { + public function processUser(User $user): void { + // 2-level chain: $user->address → Address, then ->save() → Address#save + $user->address->save(); + + // 3-level chain: $user->address → Address, ->city → City, ->getName() → City#getName + $user->address->city->getName(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-field-types/Models.php b/gitnexus/test/fixtures/lang-resolution/php-field-types/Models.php new file mode 100644 index 0000000000..cec490ea14 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-field-types/Models.php @@ -0,0 +1,22 @@ +<?php + +class Address { + /** @var string */ + public string $city; + + public function save(): void { + // persist address + } +} + +class User { + /** @var string */ + public string $name; + + /** @var Address */ + public Address $address; + + public function greet(): string { + return $this->name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-field-types/Service.php b/gitnexus/test/fixtures/lang-resolution/php-field-types/Service.php new file mode 100644 index 0000000000..5744b4da74 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-field-types/Service.php @@ -0,0 +1,8 @@ +<?php + +class Service { + public function processUser(User $user): void { + // Field-access chain: $user->address → Address, then ->save() → Address#save + $user->address->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/Repo.php new file mode 100644 index 0000000000..99a1b32b6f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/Repo.php @@ -0,0 +1,18 @@ +<?php + +class Repo { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): void {} +} + +/** + * @return Repo[] + */ +function getRepos(): array { + return [new Repo("main")]; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/User.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/User.php new file mode 100644 index 0000000000..8674e30c2e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/User.php @@ -0,0 +1,18 @@ +<?php + +class User { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): void {} +} + +/** + * @return User[] + */ +function getUsers(): array { + return [new User("alice")]; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/main.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/main.php new file mode 100644 index 0000000000..c8d138bfcf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-call-expr/main.php @@ -0,0 +1,16 @@ +<?php + +require_once 'User.php'; +require_once 'Repo.php'; + +function processUsers(): void { + foreach (getUsers() as $user) { + $user->save(); + } +} + +function processRepos(): void { + foreach (getRepos() as $repo) { + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/App.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/App.php new file mode 100644 index 0000000000..4f4d143420 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/App.php @@ -0,0 +1,26 @@ +<?php + +require_once 'User.php'; +require_once 'Repo.php'; + +class App { + /** + * PHPDoc generic Collection<User> — element type should resolve to User, not Collection. + * @param Collection<User> $users + */ + public function processCollection($users): void { + foreach ($users as $user) { + $user->save(); + } + } + + /** + * PHPDoc array-style User[] — existing behavior, should still work. + * @param User[] $repos + */ + public function processArray(array $repos): void { + foreach ($repos as $repo) { + $repo->save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/Repo.php new file mode 100644 index 0000000000..2a64b11be4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/Repo.php @@ -0,0 +1,11 @@ +<?php + +class Repo { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/User.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/User.php new file mode 100644 index 0000000000..437c130283 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-generic/User.php @@ -0,0 +1,11 @@ +<?php + +class User { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/App.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/App.php new file mode 100644 index 0000000000..cea2c74e10 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/App.php @@ -0,0 +1,12 @@ +<?php + +require_once 'User.php'; + +class App { + /** @param User[] $users */ + public function processUsers(array $users): void { + foreach ($users as $user) { + $user->save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/Repo.php new file mode 100644 index 0000000000..2a64b11be4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/Repo.php @@ -0,0 +1,11 @@ +<?php + +class Repo { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/User.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/User.php new file mode 100644 index 0000000000..437c130283 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-loop/User.php @@ -0,0 +1,11 @@ +<?php + +class User { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/App.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/App.php new file mode 100644 index 0000000000..1750a191cd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/App.php @@ -0,0 +1,24 @@ +<?php + +require_once 'User.php'; +require_once 'Repo.php'; + +class App { + /** @var User[] */ + private array $users; + + public function __construct() { + $this->users = []; + } + + /** + * $this->users member access in foreach — resolved via Phase 7.4 Strategy C: + * scans the class body for the property_declaration and extracts the element + * type from the @var PHPDoc annotation without requiring a @param workaround. + */ + public function processMembers(): void { + foreach ($this->users as $user) { + $user->save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/Repo.php new file mode 100644 index 0000000000..2a64b11be4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/Repo.php @@ -0,0 +1,11 @@ +<?php + +class Repo { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/User.php b/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/User.php new file mode 100644 index 0000000000..437c130283 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-foreach-member-access/User.php @@ -0,0 +1,11 @@ +<?php + +class User { + public string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Models/Repo.php new file mode 100644 index 0000000000..a4cd5c1a88 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Models/Repo.php @@ -0,0 +1,8 @@ +<?php +namespace App\Models; + +class Repo { + public function persist(): void { + echo "persisting repo"; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Models/User.php new file mode 100644 index 0000000000..65446930c0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Models/User.php @@ -0,0 +1,8 @@ +<?php +namespace App\Models; + +class User { + public function save(): void { + echo "saving user"; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Services/Main.php b/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Services/Main.php new file mode 100644 index 0000000000..20aa62cb48 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/app/Services/Main.php @@ -0,0 +1,14 @@ +<?php +namespace App\Services; + +use App\Models\{User, Repo as R}; + +class Main { + public function run(): void { + $u = new User(); + $u->save(); + + $r = new R(); + $r->persist(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/composer.json b/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-grouped-imports/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-local-shadow/app/Services/Main.php b/gitnexus/test/fixtures/lang-resolution/php-local-shadow/app/Services/Main.php new file mode 100644 index 0000000000..6e69a356a1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-local-shadow/app/Services/Main.php @@ -0,0 +1,13 @@ +<?php +namespace App\Services; + +use function App\Utils\save; + +// Local function shadows imported save +function save(string $data): void { + echo "local save: $data\n"; +} + +function run(): void { + save("test"); +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-local-shadow/app/Utils/Logger.php b/gitnexus/test/fixtures/lang-resolution/php-local-shadow/app/Utils/Logger.php new file mode 100644 index 0000000000..cc2498ee39 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-local-shadow/app/Utils/Logger.php @@ -0,0 +1,6 @@ +<?php +namespace App\Utils; + +function save(string $data): void { + echo "utils save: $data\n"; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-local-shadow/composer.json b/gitnexus/test/fixtures/lang-resolution/php-local-shadow/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-local-shadow/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-member-calls/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-member-calls/app/Models/User.php new file mode 100644 index 0000000000..b43d560830 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-member-calls/app/Models/User.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Models; + +class User +{ + public function save(): bool + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-member-calls/app/Services/UserService.php b/gitnexus/test/fixtures/lang-resolution/php-member-calls/app/Services/UserService.php new file mode 100644 index 0000000000..1855817bb7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-member-calls/app/Services/UserService.php @@ -0,0 +1,14 @@ +<?php + +namespace App\Services; + +use App\Models\User; + +class UserService +{ + public function processUser(): bool + { + $user = new User(); + return $user->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-member-calls/composer.json b/gitnexus/test/fixtures/lang-resolution/php-member-calls/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-member-calls/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Models/Repo.php new file mode 100644 index 0000000000..d3670e2f51 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Models/Repo.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Models; + +class Repo +{ + public function save(): bool + { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Models/User.php new file mode 100644 index 0000000000..b43d560830 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Models/User.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Models; + +class User +{ + public function save(): bool + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Services/AppService.php b/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Services/AppService.php new file mode 100644 index 0000000000..fb7f2c1208 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/app/Services/AppService.php @@ -0,0 +1,16 @@ +<?php + +namespace App\Services; + +use App\Models\User; +use App\Models\Repo; + +class AppService +{ + public function process(?User $user, ?Repo $repo): void + { + // Nullable type-hinted params — should disambiguate via unwrapped type + $user->save(); + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/composer.json b/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-nullable-receiver/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/BaseModel.php b/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/BaseModel.php new file mode 100644 index 0000000000..38ecfbf1d9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/BaseModel.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Models; + +class BaseModel +{ + public function save(): bool { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/Serializable.php b/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/Serializable.php new file mode 100644 index 0000000000..a7243079f9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/Serializable.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Models; + +interface Serializable +{ + public function serialize(): string; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/User.php new file mode 100644 index 0000000000..8c10abd78c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/app/Models/User.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Models; + +class User extends BaseModel implements Serializable +{ + public function serialize(): string { return ''; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/composer.json b/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/composer.json new file mode 100644 index 0000000000..60ede80e5e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-parent-resolution/composer.json @@ -0,0 +1,5 @@ +{ + "autoload": { + "psr-4": { "App\\": "app/" } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-phpdoc-attribute-return-type/Models.php b/gitnexus/test/fixtures/lang-resolution/php-phpdoc-attribute-return-type/Models.php new file mode 100644 index 0000000000..997516ec83 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-phpdoc-attribute-return-type/Models.php @@ -0,0 +1,8 @@ +<?php +class User { + public function save() { return true; } +} + +class Repo { + public function save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-phpdoc-attribute-return-type/Services.php b/gitnexus/test/fixtures/lang-resolution/php-phpdoc-attribute-return-type/Services.php new file mode 100644 index 0000000000..73fb9d18b0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-phpdoc-attribute-return-type/Services.php @@ -0,0 +1,46 @@ +<?php +require_once 'Models.php'; + +class UserService { + /** + * @return User + */ + #[Route('/user')] + public function getUser(string $name) { + return new User(); + } + + /** + * @return Repo + */ + #[Route('/repo')] + public function getRepo(string $path) { + return new Repo(); + } + + public function processUser() { + $user = $this->getUser("alice"); + $user->save(); + } + + public function processRepo() { + $repo = $this->getRepo("/data"); + $repo->save(); + } + + /** + * @param User $user the user to handle + */ + #[Validate] + public function handleUser($user) { + $user->save(); + } + + /** + * @param Repo $repo the repo to handle + */ + #[Validate] + public function handleRepo($repo) { + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-phpdoc-return-type/Models.php b/gitnexus/test/fixtures/lang-resolution/php-phpdoc-return-type/Models.php new file mode 100644 index 0000000000..997516ec83 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-phpdoc-return-type/Models.php @@ -0,0 +1,8 @@ +<?php +class User { + public function save() { return true; } +} + +class Repo { + public function save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-phpdoc-return-type/Services.php b/gitnexus/test/fixtures/lang-resolution/php-phpdoc-return-type/Services.php new file mode 100644 index 0000000000..b08d37a4c7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-phpdoc-return-type/Services.php @@ -0,0 +1,42 @@ +<?php +require_once 'Models.php'; + +class UserService { + /** + * @return User + */ + public function getUser(string $name) { + return new User(); + } + + /** + * @return Repo + */ + public function getRepo(string $path) { + return new Repo(); + } + + public function processUser() { + $user = $this->getUser("alice"); + $user->save(); + } + + public function processRepo() { + $repo = $this->getRepo("/data"); + $repo->save(); + } + + /** + * @param User $user the user to handle + */ + public function handleUser($user) { + $user->save(); + } + + /** + * @param Repo $repo the repo to handle + */ + public function handleRepo($repo) { + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-property-promotion/UserService.php b/gitnexus/test/fixtures/lang-resolution/php-property-promotion/UserService.php new file mode 100644 index 0000000000..12bccc3a61 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-property-promotion/UserService.php @@ -0,0 +1,15 @@ +<?php + +class UserRepo { + public function find(int $id): void {} + public function save(): void {} +} + +class UserService { + public function __construct( + private UserRepo $repo + ) { + // Promoted parameter $repo is available as a local variable in the constructor + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Models/Repo.php new file mode 100644 index 0000000000..d3670e2f51 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Models/Repo.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Models; + +class Repo +{ + public function save(): bool + { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Models/User.php new file mode 100644 index 0000000000..b43d560830 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Models/User.php @@ -0,0 +1,11 @@ +<?php + +namespace App\Models; + +class User +{ + public function save(): bool + { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Services/AppService.php b/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Services/AppService.php new file mode 100644 index 0000000000..af70faeeb5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/app/Services/AppService.php @@ -0,0 +1,15 @@ +<?php + +namespace App\Services; + +use App\Models\User; +use App\Models\Repo; + +class AppService +{ + public function processEntities(User $user, Repo $repo): void + { + $user->save(); + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/composer.json b/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-receiver-resolution/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Models/Repo.php new file mode 100644 index 0000000000..7094638a7a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Models/Repo.php @@ -0,0 +1,9 @@ +<?php + +namespace App\Models; + +class Repo { + public function save(): bool { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Models/User.php new file mode 100644 index 0000000000..481a1b39af --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Models/User.php @@ -0,0 +1,15 @@ +<?php + +namespace App\Models; + +class User { + private string $name; + + public function __construct(string $name) { + $this->name = $name; + } + + public function save(): bool { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Services/UserService.php b/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Services/UserService.php new file mode 100644 index 0000000000..6f366dbceb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-return-type/app/Services/UserService.php @@ -0,0 +1,16 @@ +<?php + +namespace App\Services; + +use App\Models\User; + +class UserService { + public function getUser(string $name): User { + return new User($name); + } + + public function processUser(): void { + $user = $this->getUser("alice"); + $user->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/app/Models/Repo.php new file mode 100644 index 0000000000..83a5311bc9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/app/Models/Repo.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Models; + +class Repo +{ + public function save(): bool { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/app/Models/User.php new file mode 100644 index 0000000000..3e2974f25b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/app/Models/User.php @@ -0,0 +1,12 @@ +<?php + +namespace App\Models; + +class User +{ + public function save(): bool { return true; } + public function process(): void + { + $this->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/composer.json b/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/composer.json new file mode 100644 index 0000000000..60ede80e5e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-self-this-resolution/composer.json @@ -0,0 +1,5 @@ +{ + "autoload": { + "psr-4": { "App\\": "app/" } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/BaseModel.php b/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/BaseModel.php new file mode 100644 index 0000000000..38ecfbf1d9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/BaseModel.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Models; + +class BaseModel +{ + public function save(): bool { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/Repo.php b/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/Repo.php new file mode 100644 index 0000000000..83a5311bc9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/Repo.php @@ -0,0 +1,8 @@ +<?php + +namespace App\Models; + +class Repo +{ + public function save(): bool { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/User.php b/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/User.php new file mode 100644 index 0000000000..21ede6c09f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-super-resolution/app/Models/User.php @@ -0,0 +1,12 @@ +<?php + +namespace App\Models; + +class User extends BaseModel +{ + public function save(): bool + { + parent::save(); + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-super-resolution/composer.json b/gitnexus/test/fixtures/lang-resolution/php-super-resolution/composer.json new file mode 100644 index 0000000000..60ede80e5e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-super-resolution/composer.json @@ -0,0 +1,5 @@ +{ + "autoload": { + "psr-4": { "App\\": "app/" } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/AdminService.php b/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/AdminService.php new file mode 100644 index 0000000000..5d4be53fbd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/AdminService.php @@ -0,0 +1,14 @@ +<?php +require_once 'Models.php'; + +class AdminService { + /** @return Repo */ + public function getUser(string $name) { + return new Repo(); + } + + public function processAdmin() { + $repo = $this->getUser("admin"); + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/Models.php b/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/Models.php new file mode 100644 index 0000000000..997516ec83 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/Models.php @@ -0,0 +1,8 @@ +<?php +class User { + public function save() { return true; } +} + +class Repo { + public function save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/UserService.php b/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/UserService.php new file mode 100644 index 0000000000..42eaf3cce7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-this-receiver-disambiguation/UserService.php @@ -0,0 +1,14 @@ +<?php +require_once 'Models.php'; + +class UserService { + /** @return User */ + public function getUser(string $name) { + return new User(); + } + + public function processUser() { + $user = $this->getUser("alice"); + $user->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-typed-properties/app/Models/UserRepo.php b/gitnexus/test/fixtures/lang-resolution/php-typed-properties/app/Models/UserRepo.php new file mode 100644 index 0000000000..ba4f82e4d2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-typed-properties/app/Models/UserRepo.php @@ -0,0 +1,9 @@ +<?php + +namespace App\Models; + +class UserRepo +{ + public function find(int $id): void {} + public function save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-typed-properties/app/Services/UserService.php b/gitnexus/test/fixtures/lang-resolution/php-typed-properties/app/Services/UserService.php new file mode 100644 index 0000000000..3410886739 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-typed-properties/app/Services/UserService.php @@ -0,0 +1,15 @@ +<?php + +namespace App\Services; + +use App\Models\UserRepo; + +class UserService +{ + private UserRepo $repo; + + public function process(UserRepo $repo): void + { + $repo->save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-typed-properties/composer.json b/gitnexus/test/fixtures/lang-resolution/php-typed-properties/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-typed-properties/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/app/Services/AppService.php b/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/app/Services/AppService.php new file mode 100644 index 0000000000..6b44c47199 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/app/Services/AppService.php @@ -0,0 +1,10 @@ +<?php +namespace App\Services; + +use App\Utils\Logger; + +class AppService { + public function run(): void { + Logger::record("info", "started", "processing", "done"); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/app/Utils/Logger.php b/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/app/Utils/Logger.php new file mode 100644 index 0000000000..45cdb22400 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/app/Utils/Logger.php @@ -0,0 +1,10 @@ +<?php +namespace App\Utils; + +class Logger { + public static function record(string $level, string ...$messages): void { + foreach ($messages as $msg) { + echo "[$level] $msg\n"; + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/composer.json b/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/composer.json new file mode 100644 index 0000000000..386b0bd2d7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-variadic-resolution/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "app/" + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-write-access/models.php b/gitnexus/test/fixtures/lang-resolution/php-write-access/models.php new file mode 100644 index 0000000000..d34c17bc35 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-write-access/models.php @@ -0,0 +1,11 @@ +<?php + +class Address { + public string $city; +} + +class User { + public string $name; + public Address $address; + public static int $count = 0; +} diff --git a/gitnexus/test/fixtures/lang-resolution/php-write-access/service.php b/gitnexus/test/fixtures/lang-resolution/php-write-access/service.php new file mode 100644 index 0000000000..c350e66e3b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/php-write-access/service.php @@ -0,0 +1,17 @@ +<?php + +require_once 'models.php'; + +function updateUser(User $user) { + // Simple write + $user->name = "Alice"; + + // Object write + $user->address = new Address(); + + // Static property write + User::$count = 42; + + // Compound assignment write + $user->name .= " Smith"; +} diff --git a/gitnexus/test/fixtures/lang-resolution/python-alias-imports/app.py b/gitnexus/test/fixtures/lang-resolution/python-alias-imports/app.py new file mode 100644 index 0000000000..f829237ca8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-alias-imports/app.py @@ -0,0 +1,7 @@ +from models import User as U, Repo as R + +def main(): + u = U("alice") + r = R("https://example.com") + u.save() + r.persist() diff --git a/gitnexus/test/fixtures/lang-resolution/python-alias-imports/models.py b/gitnexus/test/fixtures/lang-resolution/python-alias-imports/models.py new file mode 100644 index 0000000000..e87c933c75 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-alias-imports/models.py @@ -0,0 +1,13 @@ +class User: + def __init__(self, name): + self.name = name + + def save(self): + return True + +class Repo: + def __init__(self, url): + self.url = url + + def persist(self): + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-ambiguous/models/__init__.py b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/models/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gitnexus/test/fixtures/lang-resolution/python-ambiguous/models/handler.py b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/models/handler.py new file mode 100644 index 0000000000..afd1c741a5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/models/handler.py @@ -0,0 +1,3 @@ +class Handler: + def handle(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-ambiguous/other/__init__.py b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/other/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gitnexus/test/fixtures/lang-resolution/python-ambiguous/other/handler.py b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/other/handler.py new file mode 100644 index 0000000000..746cc3930b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/other/handler.py @@ -0,0 +1,3 @@ +class Handler: + def process(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-ambiguous/services/__init__.py b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/services/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gitnexus/test/fixtures/lang-resolution/python-ambiguous/services/user_handler.py b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/services/user_handler.py new file mode 100644 index 0000000000..feb5b66fc6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-ambiguous/services/user_handler.py @@ -0,0 +1,5 @@ +from ..models.handler import Handler + +class UserHandler(Handler): + def run(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/app.py b/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/app.py new file mode 100644 index 0000000000..7277e39043 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/app.py @@ -0,0 +1,17 @@ +from user import User +from repo import Repo + +def get_user() -> User: + return User() + +def get_repo() -> Repo: + return Repo() + +def process(): + u: User = get_user() + alias = u + alias.save() + + r: Repo = get_repo() + r_alias = r + r_alias.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/repo.py b/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/repo.py new file mode 100644 index 0000000000..18ce75c496 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self): + return False diff --git a/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/user.py b/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/user.py new file mode 100644 index 0000000000..a9220e7448 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-assignment-chain/user.py @@ -0,0 +1,3 @@ +class User: + def save(self): + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-bare-import/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-bare-import/models/user.py new file mode 100644 index 0000000000..96f70f4d8e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-bare-import/models/user.py @@ -0,0 +1,3 @@ +class User: + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-bare-import/services/auth.py b/gitnexus/test/fixtures/lang-resolution/python-bare-import/services/auth.py new file mode 100644 index 0000000000..c7e9edb1b9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-bare-import/services/auth.py @@ -0,0 +1,5 @@ +import user + +def authenticate(): + svc = user.UserService() + svc.execute() diff --git a/gitnexus/test/fixtures/lang-resolution/python-bare-import/services/user.py b/gitnexus/test/fixtures/lang-resolution/python-bare-import/services/user.py new file mode 100644 index 0000000000..6b0bea09bf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-bare-import/services/user.py @@ -0,0 +1,3 @@ +class UserService: + def execute(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-calls/one.py b/gitnexus/test/fixtures/lang-resolution/python-calls/one.py new file mode 100644 index 0000000000..9d91ba3893 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-calls/one.py @@ -0,0 +1,2 @@ +def write_audit(message): + return message diff --git a/gitnexus/test/fixtures/lang-resolution/python-calls/service.py b/gitnexus/test/fixtures/lang-resolution/python-calls/service.py new file mode 100644 index 0000000000..c13d420798 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-calls/service.py @@ -0,0 +1,6 @@ +from one import write_audit +from zero import write_audit as zero_write_audit + + +def run(): + return write_audit("hello") diff --git a/gitnexus/test/fixtures/lang-resolution/python-calls/zero.py b/gitnexus/test/fixtures/lang-resolution/python-calls/zero.py new file mode 100644 index 0000000000..14815b43ea --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-calls/zero.py @@ -0,0 +1,2 @@ +def write_audit(): + return "zero" diff --git a/gitnexus/test/fixtures/lang-resolution/python-chain-call/app.py b/gitnexus/test/fixtures/lang-resolution/python-chain-call/app.py new file mode 100644 index 0000000000..f924be17cc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-chain-call/app.py @@ -0,0 +1,6 @@ +from service import UserService + + +def process_user(): + svc = UserService() + svc.get_user().save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-chain-call/models/repo.py b/gitnexus/test/fixtures/lang-resolution/python-chain-call/models/repo.py new file mode 100644 index 0000000000..3b88a9847c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-chain-call/models/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-chain-call/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-chain-call/models/user.py new file mode 100644 index 0000000000..96f70f4d8e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-chain-call/models/user.py @@ -0,0 +1,3 @@ +class User: + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-chain-call/service.py b/gitnexus/test/fixtures/lang-resolution/python-chain-call/service.py new file mode 100644 index 0000000000..7118aba7fe --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-chain-call/service.py @@ -0,0 +1,6 @@ +from models.user import User + + +class UserService: + def get_user(self) -> User: + return User() diff --git a/gitnexus/test/fixtures/lang-resolution/python-class-annotations/repo.py b/gitnexus/test/fixtures/lang-resolution/python-class-annotations/repo.py new file mode 100644 index 0000000000..792eaf081d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-class-annotations/repo.py @@ -0,0 +1,5 @@ +class Repo: + name: str = "" + + def save(self): + return False diff --git a/gitnexus/test/fixtures/lang-resolution/python-class-annotations/service.py b/gitnexus/test/fixtures/lang-resolution/python-class-annotations/service.py new file mode 100644 index 0000000000..ce0a999e7b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-class-annotations/service.py @@ -0,0 +1,10 @@ +from user import User +from repo import Repo + +# File-level class annotations (no default) +active_user: User +active_repo: Repo + +def process(): + active_user.save() + active_repo.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-class-annotations/user.py b/gitnexus/test/fixtures/lang-resolution/python-class-annotations/user.py new file mode 100644 index 0000000000..71899ec86a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-class-annotations/user.py @@ -0,0 +1,5 @@ +class User: + name: str = "" + + def save(self): + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-constructor-calls/app.py b/gitnexus/test/fixtures/lang-resolution/python-constructor-calls/app.py new file mode 100644 index 0000000000..ce979d6f9f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-constructor-calls/app.py @@ -0,0 +1,5 @@ +from models import User + +def process(): + user = User("alice") + user.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-constructor-calls/models.py b/gitnexus/test/fixtures/lang-resolution/python-constructor-calls/models.py new file mode 100644 index 0000000000..08d83d1afe --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-constructor-calls/models.py @@ -0,0 +1,6 @@ +class User: + def __init__(self, name): + self.name = name + + def save(self): + print('saving user') diff --git a/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/models/repo.py b/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/models/repo.py new file mode 100644 index 0000000000..d17e71270b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/models/repo.py @@ -0,0 +1,6 @@ +class Repo: + def __init__(self, db_name: str): + self.db_name = db_name + + def save(self) -> bool: + return False diff --git a/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/models/user.py new file mode 100644 index 0000000000..c0ddac39f8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/models/user.py @@ -0,0 +1,6 @@ +class User: + def __init__(self, name: str): + self.name = name + + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/services/app.py b/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/services/app.py new file mode 100644 index 0000000000..9a5162c9f7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-constructor-type-inference/services/app.py @@ -0,0 +1,9 @@ +from models.user import User +from models.repo import Repo + + +def process_entities(): + user = User("alice") + repo = Repo("maindb") + user.save() + repo.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/app.py b/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/app.py new file mode 100644 index 0000000000..2d78849a7c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/app.py @@ -0,0 +1,5 @@ +from user import User + +def process(data: dict[str, User]): + for key, user in data.items(): + user.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/repo.py b/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/repo.py new file mode 100644 index 0000000000..2ab5d4e66b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/repo.py @@ -0,0 +1,6 @@ +class Repo: + def __init__(self, name: str): + self.name = name + + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/user.py b/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/user.py new file mode 100644 index 0000000000..ce4796bd0e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-dict-items-loop/user.py @@ -0,0 +1,6 @@ +class User: + def __init__(self, name: str): + self.name = name + + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/app.py b/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/app.py new file mode 100644 index 0000000000..be3a8ff56e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/app.py @@ -0,0 +1,20 @@ +from user import User +from typing import List + + +def process_users(users: dict[str, User]): + # 3-variable enumerate: i=index, k=key, v=value (User) + for i, k, v in enumerate(users.items()): + v.save() + + +def process_nested_tuple(users: dict[str, User]): + # Nested tuple pattern: i=index, (k,v) tuple unpacked + for i, (k, v) in enumerate(users.items()): + v.save() + + +def process_parenthesized_tuple(users: List[User]): + # Parenthesized tuple as top-level pattern + for (i, u) in enumerate(users): + u.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/repo.py b/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/repo.py new file mode 100644 index 0000000000..ec93e0e2f4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/user.py b/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/user.py new file mode 100644 index 0000000000..c0ddac39f8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-enumerate-loop/user.py @@ -0,0 +1,6 @@ +class User: + def __init__(self, name: str): + self.name = name + + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/address.py b/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/address.py new file mode 100644 index 0000000000..83754b8df1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/address.py @@ -0,0 +1,5 @@ +class Address: + city: str + + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/service.py b/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/service.py new file mode 100644 index 0000000000..443bce2bb8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/service.py @@ -0,0 +1,6 @@ +from user import User + +def process_user(user: User): + # Field-access chain: user.address → Address, then .save() must resolve + # to Address#save (NOT User#save) — only lookupFieldByOwner can disambiguate. + user.address.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/user.py b/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/user.py new file mode 100644 index 0000000000..3681631d5c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-field-type-disambig/user.py @@ -0,0 +1,8 @@ +from address import Address + +class User: + name: str + address: Address + + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-field-types/models.py b/gitnexus/test/fixtures/lang-resolution/python-field-types/models.py new file mode 100644 index 0000000000..fccf42ae22 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-field-types/models.py @@ -0,0 +1,12 @@ +class Address: + city: str + + def save(self): + pass + +class User: + name: str + address: Address + + def greet(self) -> str: + return self.name diff --git a/gitnexus/test/fixtures/lang-resolution/python-field-types/service.py b/gitnexus/test/fixtures/lang-resolution/python-field-types/service.py new file mode 100644 index 0000000000..f7c2a8d743 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-field-types/service.py @@ -0,0 +1,4 @@ +from models import User + +def process_user(user: User): + user.address.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-for-call-expr/main.py b/gitnexus/test/fixtures/lang-resolution/python-for-call-expr/main.py new file mode 100644 index 0000000000..58bfe40b12 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-for-call-expr/main.py @@ -0,0 +1,9 @@ +from models import get_users, get_repos + +def process_users(): + for user in get_users(): + user.save() + +def process_repos(): + for repo in get_repos(): + repo.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-for-call-expr/models.py b/gitnexus/test/fixtures/lang-resolution/python-for-call-expr/models.py new file mode 100644 index 0000000000..822eece853 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-for-call-expr/models.py @@ -0,0 +1,19 @@ +class User: + def __init__(self, name: str): + self.name = name + + def save(self) -> None: + pass + +class Repo: + def __init__(self, name: str): + self.name = name + + def save(self) -> None: + pass + +def get_users() -> list[User]: + return [User("alice")] + +def get_repos() -> list[Repo]: + return [Repo("main")] diff --git a/gitnexus/test/fixtures/lang-resolution/python-local-shadow/app.py b/gitnexus/test/fixtures/lang-resolution/python-local-shadow/app.py new file mode 100644 index 0000000000..71c896100f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-local-shadow/app.py @@ -0,0 +1,7 @@ +from utils import save + +def save(x): + print('local save') + +def main(): + save("test") diff --git a/gitnexus/test/fixtures/lang-resolution/python-local-shadow/utils.py b/gitnexus/test/fixtures/lang-resolution/python-local-shadow/utils.py new file mode 100644 index 0000000000..891171736c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-local-shadow/utils.py @@ -0,0 +1,2 @@ +def save(data): + print('saving from utils') diff --git a/gitnexus/test/fixtures/lang-resolution/python-match-case/app.py b/gitnexus/test/fixtures/lang-resolution/python-match-case/app.py new file mode 100644 index 0000000000..b56eae4eed --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-match-case/app.py @@ -0,0 +1,8 @@ +from models.user import User +from models.repo import Repo + + +def process(x): + match x: + case User() as u: + u.save() # should resolve to User#save, not Repo#save diff --git a/gitnexus/test/fixtures/lang-resolution/python-match-case/models/repo.py b/gitnexus/test/fixtures/lang-resolution/python-match-case/models/repo.py new file mode 100644 index 0000000000..3b88a9847c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-match-case/models/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-match-case/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-match-case/models/user.py new file mode 100644 index 0000000000..96f70f4d8e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-match-case/models/user.py @@ -0,0 +1,3 @@ +class User: + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/app.py b/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/app.py new file mode 100644 index 0000000000..d91be40f57 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/app.py @@ -0,0 +1,13 @@ +from models.user import User +from models.repo import Repo +from typing import List + +class UserService: + def process_users(self, users: List[User]): + for user in self.users: + user.save() + +class RepoService: + def process_repos(self, repos: List[Repo]): + for repo in self.repos: + repo.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/models/repo.py b/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/models/repo.py new file mode 100644 index 0000000000..3b88a9847c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/models/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/models/user.py new file mode 100644 index 0000000000..96f70f4d8e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-member-access-for-loop/models/user.py @@ -0,0 +1,3 @@ +class User: + def save(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-member-calls/app.py b/gitnexus/test/fixtures/lang-resolution/python-member-calls/app.py new file mode 100644 index 0000000000..1e9d57753f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-member-calls/app.py @@ -0,0 +1,5 @@ +from user import User + +def process_user(): + user = User() + return user.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-member-calls/user.py b/gitnexus/test/fixtures/lang-resolution/python-member-calls/user.py new file mode 100644 index 0000000000..a9220e7448 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-member-calls/user.py @@ -0,0 +1,3 @@ +class User: + def save(self): + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-named-imports/app.py b/gitnexus/test/fixtures/lang-resolution/python-named-imports/app.py new file mode 100644 index 0000000000..dc067d55cf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-named-imports/app.py @@ -0,0 +1,4 @@ +from format_upper import format_data + +def process_input(): + return format_data("hello") diff --git a/gitnexus/test/fixtures/lang-resolution/python-named-imports/format_prefix.py b/gitnexus/test/fixtures/lang-resolution/python-named-imports/format_prefix.py new file mode 100644 index 0000000000..7093bac8c9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-named-imports/format_prefix.py @@ -0,0 +1,2 @@ +def format_data(data, prefix): + return prefix + data diff --git a/gitnexus/test/fixtures/lang-resolution/python-named-imports/format_upper.py b/gitnexus/test/fixtures/lang-resolution/python-named-imports/format_upper.py new file mode 100644 index 0000000000..1382331bf7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-named-imports/format_upper.py @@ -0,0 +1,2 @@ +def format_data(data): + return data.upper() diff --git a/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/app.py b/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/app.py new file mode 100644 index 0000000000..f04a0788bb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/app.py @@ -0,0 +1,24 @@ +from user import User +from repo import Repo + + +def get_user() -> User: + return User() + + +def get_repo() -> Repo: + return Repo() + + +# Python 3.10+ union: User | None is parsed as binary_operator, +# stored as raw text "User | None" in TypeEnv, then stripNullable resolves it. +def nullable_chain_user() -> None: + u: User | None = get_user() + alias = u + alias.save() + + +def nullable_chain_repo() -> None: + r: Repo | None = get_repo() + alias = r + alias.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/repo.py b/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/repo.py new file mode 100644 index 0000000000..0d725eb538 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self) -> bool: + return False diff --git a/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/user.py b/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/user.py new file mode 100644 index 0000000000..8ef6bb4194 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-nullable-chain/user.py @@ -0,0 +1,3 @@ +class User: + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/app.py b/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/app.py new file mode 100644 index 0000000000..4521d5913d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/app.py @@ -0,0 +1,14 @@ +from user import User +from repo import Repo + +def find_user() -> User | None: + return User() + +def find_repo() -> Repo | None: + return Repo() + +def process_entities(): + user: User | None = find_user() + user.save() + repo: Repo | None = find_repo() + repo.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/repo.py b/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/repo.py new file mode 100644 index 0000000000..18ce75c496 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self): + return False diff --git a/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/user.py b/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/user.py new file mode 100644 index 0000000000..a9220e7448 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-nullable-receiver/user.py @@ -0,0 +1,3 @@ +class User: + def save(self): + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-parent-resolution/models/__init__.py b/gitnexus/test/fixtures/lang-resolution/python-parent-resolution/models/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gitnexus/test/fixtures/lang-resolution/python-parent-resolution/models/base.py b/gitnexus/test/fixtures/lang-resolution/python-parent-resolution/models/base.py new file mode 100644 index 0000000000..d105e82e1d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-parent-resolution/models/base.py @@ -0,0 +1,3 @@ +class BaseModel: + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-parent-resolution/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-parent-resolution/models/user.py new file mode 100644 index 0000000000..5b73530b91 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-parent-resolution/models/user.py @@ -0,0 +1,5 @@ +from .base import BaseModel + +class User(BaseModel): + def serialize(self) -> str: + return '' diff --git a/gitnexus/test/fixtures/lang-resolution/python-pkg/models/base.py b/gitnexus/test/fixtures/lang-resolution/python-pkg/models/base.py new file mode 100644 index 0000000000..cbd7d8e61c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-pkg/models/base.py @@ -0,0 +1,6 @@ +class BaseModel: + def save(self): + pass + + def validate(self): + pass diff --git a/gitnexus/test/fixtures/lang-resolution/python-pkg/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-pkg/models/user.py new file mode 100644 index 0000000000..e1460af940 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-pkg/models/user.py @@ -0,0 +1,6 @@ +from .base import BaseModel + + +class User(BaseModel): + def get_name(self): + return self.name diff --git a/gitnexus/test/fixtures/lang-resolution/python-pkg/services/auth.py b/gitnexus/test/fixtures/lang-resolution/python-pkg/services/auth.py new file mode 100644 index 0000000000..f4db8eb46d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-pkg/services/auth.py @@ -0,0 +1,7 @@ +from ..models.user import User + + +class AuthService: + def authenticate(self, user: User): + user.validate() + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-pkg/utils/helpers.py b/gitnexus/test/fixtures/lang-resolution/python-pkg/utils/helpers.py new file mode 100644 index 0000000000..a92d93ba3a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-pkg/utils/helpers.py @@ -0,0 +1,6 @@ +from ..models.base import BaseModel + + +def process_model(model: BaseModel): + model.validate() + model.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-qualified-constructor/main.py b/gitnexus/test/fixtures/lang-resolution/python-qualified-constructor/main.py new file mode 100644 index 0000000000..40132cbccb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-qualified-constructor/main.py @@ -0,0 +1,6 @@ +import models + +def main(): + user = models.User("alice") + user.save() + user.greet() diff --git a/gitnexus/test/fixtures/lang-resolution/python-qualified-constructor/models.py b/gitnexus/test/fixtures/lang-resolution/python-qualified-constructor/models.py new file mode 100644 index 0000000000..69133bb963 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-qualified-constructor/models.py @@ -0,0 +1,9 @@ +class User: + def __init__(self, name): + self.name = name + + def save(self): + pass + + def greet(self): + return f"Hello, {self.name}" diff --git a/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/app.py b/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/app.py new file mode 100644 index 0000000000..49d7dcf232 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/app.py @@ -0,0 +1,8 @@ +from user import User +from repo import Repo + +def process_entities(): + user: User = User() + repo: Repo = Repo() + user.save() + repo.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/repo.py b/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/repo.py new file mode 100644 index 0000000000..18ce75c496 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self): + return False diff --git a/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/user.py b/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/user.py new file mode 100644 index 0000000000..a9220e7448 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-receiver-resolution/user.py @@ -0,0 +1,3 @@ +class User: + def save(self): + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/app.py b/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/app.py new file mode 100644 index 0000000000..2e8dc70194 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/app.py @@ -0,0 +1,8 @@ +from models import User, Repo + +def main(): + user = User() + user.save() + + repo = Repo() + repo.persist() diff --git a/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/models/__init__.py b/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/models/__init__.py new file mode 100644 index 0000000000..e36f124b8b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/models/__init__.py @@ -0,0 +1 @@ +from .base import User, Repo diff --git a/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/models/base.py b/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/models/base.py new file mode 100644 index 0000000000..971d674ef7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-reexport-chain/models/base.py @@ -0,0 +1,7 @@ +class User: + def save(self): + print('saving user') + +class Repo: + def persist(self): + print('persisting repo') diff --git a/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/app.py b/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/app.py new file mode 100644 index 0000000000..73f8b4764e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/app.py @@ -0,0 +1,5 @@ +from service import get_user + +def process_user(): + user = get_user('alice') + user.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/models.py b/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/models.py new file mode 100644 index 0000000000..c0ddac39f8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/models.py @@ -0,0 +1,6 @@ +class User: + def __init__(self, name: str): + self.name = name + + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/service.py b/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/service.py new file mode 100644 index 0000000000..7bf2641bd3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-return-type-inference/service.py @@ -0,0 +1,4 @@ +from models import User + +def get_user(name: str) -> User: + return User(name) diff --git a/gitnexus/test/fixtures/lang-resolution/python-self-this-resolution/models/repo.py b/gitnexus/test/fixtures/lang-resolution/python-self-this-resolution/models/repo.py new file mode 100644 index 0000000000..ec93e0e2f4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-self-this-resolution/models/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-self-this-resolution/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-self-this-resolution/models/user.py new file mode 100644 index 0000000000..15d710a56f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-self-this-resolution/models/user.py @@ -0,0 +1,5 @@ +class User: + def save(self) -> bool: + return True + def process(self) -> None: + self.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-static-class-methods/app.py b/gitnexus/test/fixtures/lang-resolution/python-static-class-methods/app.py new file mode 100644 index 0000000000..36beddf0c1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-static-class-methods/app.py @@ -0,0 +1,10 @@ +from service import UserService, AdminService + + +def process(): + user = UserService.find_user("alice") + UserService.create_user("bob") + svc = UserService.from_config({}) + + AdminService.find_user("charlie") + AdminService.delete_user("charlie") diff --git a/gitnexus/test/fixtures/lang-resolution/python-static-class-methods/service.py b/gitnexus/test/fixtures/lang-resolution/python-static-class-methods/service.py new file mode 100644 index 0000000000..88add535ef --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-static-class-methods/service.py @@ -0,0 +1,22 @@ +class UserService: + @staticmethod + def find_user(name: str) -> str: + return name + + @staticmethod + def create_user(name: str) -> str: + return name + + @classmethod + def from_config(cls, config: dict) -> "UserService": + return cls() + + +class AdminService: + @staticmethod + def find_user(name: str) -> str: + return name + + @staticmethod + def delete_user(name: str) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/__init__.py b/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/base.py b/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/base.py new file mode 100644 index 0000000000..d105e82e1d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/base.py @@ -0,0 +1,3 @@ +class BaseModel: + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/repo.py b/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/repo.py new file mode 100644 index 0000000000..ec93e0e2f4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/user.py b/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/user.py new file mode 100644 index 0000000000..b7a51e51c1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-super-resolution/models/user.py @@ -0,0 +1,6 @@ +from .base import BaseModel + +class User(BaseModel): + def save(self) -> bool: + super().save() + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-variadic-resolution/app.py b/gitnexus/test/fixtures/lang-resolution/python-variadic-resolution/app.py new file mode 100644 index 0000000000..7e6e4f5fe4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-variadic-resolution/app.py @@ -0,0 +1,4 @@ +from logger import log_entry + +def process_input(): + log_entry("hello", "world", "test") diff --git a/gitnexus/test/fixtures/lang-resolution/python-variadic-resolution/logger.py b/gitnexus/test/fixtures/lang-resolution/python-variadic-resolution/logger.py new file mode 100644 index 0000000000..5b679ed84a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-variadic-resolution/logger.py @@ -0,0 +1,2 @@ +def log_entry(*messages): + print(' '.join(messages)) diff --git a/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/app.py b/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/app.py new file mode 100644 index 0000000000..645a7f9f9c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/app.py @@ -0,0 +1,30 @@ +from user import User +from repo import Repo + + +def get_user() -> User: + return User() + + +def get_repo() -> Repo: + return Repo() + + +# Walrus operator (:=) creates a named_expression binding. +# Tests that extractPendingAssignment propagates through walrus assignments. +def walrus_chain_user() -> None: + u: User = get_user() + # Regular assignment where alias gets type from u (regular chain) + alias = u + # Walrus inside condition: w gets type from u via named_expression chain + if (w := u): + w.save() + alias.save() + + +def walrus_chain_repo() -> None: + r: Repo = get_repo() + alias = r + if (w := r): + w.save() + alias.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/repo.py b/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/repo.py new file mode 100644 index 0000000000..0d725eb538 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/repo.py @@ -0,0 +1,3 @@ +class Repo: + def save(self) -> bool: + return False diff --git a/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/user.py b/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/user.py new file mode 100644 index 0000000000..8ef6bb4194 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-walrus-chain/user.py @@ -0,0 +1,3 @@ +class User: + def save(self) -> bool: + return True diff --git a/gitnexus/test/fixtures/lang-resolution/python-walrus-operator/main.py b/gitnexus/test/fixtures/lang-resolution/python-walrus-operator/main.py new file mode 100644 index 0000000000..b24b822e06 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-walrus-operator/main.py @@ -0,0 +1,6 @@ +from models import User + + +def process(): + if (user := User("alice")): + user.save() diff --git a/gitnexus/test/fixtures/lang-resolution/python-walrus-operator/models.py b/gitnexus/test/fixtures/lang-resolution/python-walrus-operator/models.py new file mode 100644 index 0000000000..a2b31a8a8d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-walrus-operator/models.py @@ -0,0 +1,9 @@ +class User: + def __init__(self, name: str): + self.name = name + + def save(self) -> bool: + return True + + def greet(self) -> str: + return f"Hello, {self.name}" diff --git a/gitnexus/test/fixtures/lang-resolution/python-write-access/models.py b/gitnexus/test/fixtures/lang-resolution/python-write-access/models.py new file mode 100644 index 0000000000..bfe176dfb3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-write-access/models.py @@ -0,0 +1,6 @@ +class Address: + city: str + +class User: + name: str + address: Address diff --git a/gitnexus/test/fixtures/lang-resolution/python-write-access/service.py b/gitnexus/test/fixtures/lang-resolution/python-write-access/service.py new file mode 100644 index 0000000000..9a76d77cf4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/python-write-access/service.py @@ -0,0 +1,6 @@ +from models import User, Address + +def update_user(user: User): + # Write access + user.name = "Alice" + user.address = Address() diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/lib/user_handler.rb b/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/lib/user_handler.rb new file mode 100644 index 0000000000..c72ff27bfd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/lib/user_handler.rb @@ -0,0 +1,7 @@ +require_relative '../models/handler' + +class UserHandler < Handler + def handle_event + process_request + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/models/handler.rb b/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/models/handler.rb new file mode 100644 index 0000000000..a51ba250c0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/models/handler.rb @@ -0,0 +1,5 @@ +class Handler + def process_request + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/other/handler.rb b/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/other/handler.rb new file mode 100644 index 0000000000..480c60b114 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-ambiguous/other/handler.rb @@ -0,0 +1,5 @@ +class Handler + def process_request + false + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/base_model.rb b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/base_model.rb new file mode 100644 index 0000000000..aa87bad8cd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/base_model.rb @@ -0,0 +1,17 @@ +require 'lib/concerns/serializable' + +class BaseModel + attr_accessor :id, :created_at + + def persist + run_validations + end + + def run_validations + true + end + + def self.factory + run_validations + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/cacheable.rb b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/cacheable.rb new file mode 100644 index 0000000000..5237d07320 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/cacheable.rb @@ -0,0 +1,5 @@ +module Cacheable + def cache_key + "key" + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/loggable.rb b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/loggable.rb new file mode 100644 index 0000000000..0098619d3a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/loggable.rb @@ -0,0 +1,5 @@ +module Loggable + def log_action + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/serializable.rb b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/serializable.rb new file mode 100644 index 0000000000..396f20518a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/concerns/serializable.rb @@ -0,0 +1,5 @@ +module Serializable + def serialize_data + "{}" + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/service.rb new file mode 100644 index 0000000000..05face3056 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/service.rb @@ -0,0 +1,9 @@ +require_relative './user' + +class UserService + def create_user + user = User.new + user.persist + user.greet_user + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/user.rb new file mode 100644 index 0000000000..0fce9b008a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-app/lib/user.rb @@ -0,0 +1,18 @@ +require_relative './base_model' +require_relative './concerns/serializable' +require_relative './concerns/loggable' +require_relative './concerns/cacheable' + +class User < BaseModel + include Serializable + extend Loggable + prepend Cacheable + + attr_reader :name + attr_writer :email + + def greet_user + persist + serialize_data + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/one_arg.rb b/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/one_arg.rb new file mode 100644 index 0000000000..58db3276c8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/one_arg.rb @@ -0,0 +1,5 @@ +class OneArg + def write_audit(message) + message + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/service.rb new file mode 100644 index 0000000000..d0e1a4fe68 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/service.rb @@ -0,0 +1,8 @@ +require_relative './one_arg' +require_relative './two_args' + +class Service + def run_task + write_audit("done") + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/two_args.rb b/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/two_args.rb new file mode 100644 index 0000000000..b4ed5d06ff --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-calls/lib/two_args.rb @@ -0,0 +1,5 @@ +class TwoArgs + def write_audit(message, level) + message + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/app.rb new file mode 100644 index 0000000000..6b15a14bc8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/app.rb @@ -0,0 +1,8 @@ +require_relative './user_service' + +class App + def process + svc = UserService.new + svc.get_user.save + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/repo.rb b/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/repo.rb new file mode 100644 index 0000000000..3e78d628c6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/repo.rb @@ -0,0 +1,5 @@ +class Repo + def save + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/user.rb new file mode 100644 index 0000000000..98ecf7994a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/user.rb @@ -0,0 +1,5 @@ +class User + def save + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/user_service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/user_service.rb new file mode 100644 index 0000000000..1b1b87524d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-chain-call/lib/user_service.rb @@ -0,0 +1,8 @@ +require_relative './user' + +class UserService + # @return [User] + def get_user + User.new + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-constant-constructor/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-constant-constructor/app.rb new file mode 100644 index 0000000000..64f5159019 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-constant-constructor/app.rb @@ -0,0 +1,5 @@ +require_relative 'models' + +SERVICE = UserService.new +SERVICE.process +SERVICE.validate diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-constant-constructor/models.rb b/gitnexus/test/fixtures/lang-resolution/ruby-constant-constructor/models.rb new file mode 100644 index 0000000000..1abcfa66f1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-constant-constructor/models.rb @@ -0,0 +1,7 @@ +class UserService + def process + end + + def validate + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/admin_service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/admin_service.rb new file mode 100644 index 0000000000..257322f788 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/admin_service.rb @@ -0,0 +1,9 @@ +class AdminService + def process + true + end + + def validate + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/app.rb new file mode 100644 index 0000000000..c87e32d6f7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/app.rb @@ -0,0 +1,11 @@ +require_relative 'user_service' +require_relative 'admin_service' + +# @return [UserService] +def build_service + UserService.new +end + +SERVICE = build_service() +SERVICE.process +SERVICE.validate diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/user_service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/user_service.rb new file mode 100644 index 0000000000..0880185717 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-constant-factory-call/user_service.rb @@ -0,0 +1,9 @@ +class UserService + def process + true + end + + def validate + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/models/repo.rb b/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/models/repo.rb new file mode 100644 index 0000000000..a5660b4f2a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/models/repo.rb @@ -0,0 +1,9 @@ +class Repo + def save + true + end + + def cleanup + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/models/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/models/user.rb new file mode 100644 index 0000000000..215b1c6924 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/models/user.rb @@ -0,0 +1,9 @@ +class User + def save + true + end + + def cleanup + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/services/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/services/app.rb new file mode 100644 index 0000000000..e82e7d2fc9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-constructor-type-inference/services/app.rb @@ -0,0 +1,20 @@ +require_relative '../models/user' +require_relative '../models/repo' + +class AppService + def process_entities + user = User.new + repo = Repo.new + user.save + repo.save + end + + def cleanup + true + end + + def greet + self.process_entities + self.cleanup + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/address.rb b/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/address.rb new file mode 100644 index 0000000000..6d96cbb106 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/address.rb @@ -0,0 +1,8 @@ +class Address + # @return [String] + attr_accessor :city + + def save + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/service.rb new file mode 100644 index 0000000000..30c7ffd2b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/service.rb @@ -0,0 +1,8 @@ +require_relative 'user' + +# @param user [User] +def process_user(user) + # Field-access chain: user.address → Address, then .save → Address#save + # Both User and Address have save — only lookupFieldByOwner can disambiguate. + user.address.save +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/user.rb new file mode 100644 index 0000000000..242e358d0e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-field-type-disambig/user.rb @@ -0,0 +1,13 @@ +require_relative 'address' + +class User + # @return [String] + attr_accessor :name + + # @return [Address] + attr_accessor :address + + def save + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-field-types/models.rb b/gitnexus/test/fixtures/lang-resolution/ruby-field-types/models.rb new file mode 100644 index 0000000000..a4bd432a75 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-field-types/models.rb @@ -0,0 +1,20 @@ +class Address + # @return [String] + attr_accessor :city + + def save + true + end +end + +class User + # @return [String] + attr_accessor :name + + # @return [Address] + attr_accessor :address + + def greet + name + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-field-types/service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-field-types/service.rb new file mode 100644 index 0000000000..a7da3e6926 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-field-types/service.rb @@ -0,0 +1,7 @@ +require_relative 'models' + +# @param user [User] +def process_user(user) + # Field-access chain: user.address → Address, then .save → Address#save + user.address.save +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/app.rb new file mode 100644 index 0000000000..9e326dd3df --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/app.rb @@ -0,0 +1,8 @@ +require_relative 'user' + +# @param users [Array<User>] +def process_users(users) + for user in users + user.save + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/repo.rb b/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/repo.rb new file mode 100644 index 0000000000..9cf9c87f77 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/repo.rb @@ -0,0 +1,8 @@ +class Repo + def initialize(name) + @name = name + end + + def save + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/user.rb new file mode 100644 index 0000000000..6c93f5b8bb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-for-in-loop/user.rb @@ -0,0 +1,8 @@ +class User + def initialize(name) + @name = name + end + + def save + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-local-shadow/lib/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-local-shadow/lib/app.rb new file mode 100644 index 0000000000..b01f293f95 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-local-shadow/lib/app.rb @@ -0,0 +1,9 @@ +require_relative './utils' + +def do_work + false +end + +def run_app + do_work +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-local-shadow/lib/utils.rb b/gitnexus/test/fixtures/lang-resolution/ruby-local-shadow/lib/utils.rb new file mode 100644 index 0000000000..539c3a9d1f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-local-shadow/lib/utils.rb @@ -0,0 +1,5 @@ +class Utils + def do_work + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-member-calls/lib/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-member-calls/lib/app.rb new file mode 100644 index 0000000000..9f00419473 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-member-calls/lib/app.rb @@ -0,0 +1,8 @@ +require_relative './user' + +class App + def process_user + user = User.new + user.persist_record + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-member-calls/lib/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-member-calls/lib/user.rb new file mode 100644 index 0000000000..4870497a05 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-member-calls/lib/user.rb @@ -0,0 +1,5 @@ +class User + def persist_record + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-namespaced-constructor/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-namespaced-constructor/app.rb new file mode 100644 index 0000000000..3f4a70dc69 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-namespaced-constructor/app.rb @@ -0,0 +1,5 @@ +require_relative 'models/user_service' + +svc = Models::UserService.new +svc.process('alice') +svc.validate diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-namespaced-constructor/models/user_service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-namespaced-constructor/models/user_service.rb new file mode 100644 index 0000000000..472fd0f53e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-namespaced-constructor/models/user_service.rb @@ -0,0 +1,11 @@ +module Models + class UserService + def process(name) + name.upcase + end + + def validate + true + end + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/base_model.rb b/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/base_model.rb new file mode 100644 index 0000000000..d024eda4c9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/base_model.rb @@ -0,0 +1,5 @@ +class BaseModel + def save + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/serializable.rb b/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/serializable.rb new file mode 100644 index 0000000000..9675515e11 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/serializable.rb @@ -0,0 +1,5 @@ +module Serializable + def serialize + '' + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/user.rb new file mode 100644 index 0000000000..49170a1b3a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-parent-resolution/lib/models/user.rb @@ -0,0 +1,6 @@ +require_relative 'base_model' +require_relative 'serializable' + +class User < BaseModel + include Serializable +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-return-type/app.rb b/gitnexus/test/fixtures/lang-resolution/ruby-return-type/app.rb new file mode 100644 index 0000000000..a092e4fc25 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-return-type/app.rb @@ -0,0 +1,12 @@ +require_relative 'models' +require_relative 'repo' + +def process_user + user = get_user('alice') + user.save +end + +def process_repo + repo = get_repo('/data') + repo.save +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-return-type/models.rb b/gitnexus/test/fixtures/lang-resolution/ruby-return-type/models.rb new file mode 100644 index 0000000000..e06220f3b5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-return-type/models.rb @@ -0,0 +1,14 @@ +class User + def initialize(name) + @name = name + end + + def save + true + end +end + +# @return [User] +def get_user(name) + User.new(name) +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-return-type/repo.rb b/gitnexus/test/fixtures/lang-resolution/ruby-return-type/repo.rb new file mode 100644 index 0000000000..7268cc96f4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-return-type/repo.rb @@ -0,0 +1,14 @@ +class Repo + def initialize(path) + @path = path + end + + def save + true + end +end + +# @return [Repo] +def get_repo(path) + Repo.new(path) +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-self-this-resolution/lib/models/repo.rb b/gitnexus/test/fixtures/lang-resolution/ruby-self-this-resolution/lib/models/repo.rb new file mode 100644 index 0000000000..3e78d628c6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-self-this-resolution/lib/models/repo.rb @@ -0,0 +1,5 @@ +class Repo + def save + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-self-this-resolution/lib/models/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-self-this-resolution/lib/models/user.rb new file mode 100644 index 0000000000..b9518e9c25 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-self-this-resolution/lib/models/user.rb @@ -0,0 +1,8 @@ +class User + def save + true + end + def process + self.save + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/base_model.rb b/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/base_model.rb new file mode 100644 index 0000000000..d024eda4c9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/base_model.rb @@ -0,0 +1,5 @@ +class BaseModel + def save + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/repo.rb b/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/repo.rb new file mode 100644 index 0000000000..3e78d628c6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/repo.rb @@ -0,0 +1,5 @@ +class Repo + def save + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/user.rb b/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/user.rb new file mode 100644 index 0000000000..a82ea78b3a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-super-resolution/lib/models/user.rb @@ -0,0 +1,8 @@ +require_relative 'base_model' + +class User < BaseModel + def save + super + true + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-write-access/models.rb b/gitnexus/test/fixtures/lang-resolution/ruby-write-access/models.rb new file mode 100644 index 0000000000..e6f1be6d20 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-write-access/models.rb @@ -0,0 +1,7 @@ +class Address + attr_accessor :city +end + +class User + attr_accessor :name, :address, :score +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-write-access/service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-write-access/service.rb new file mode 100644 index 0000000000..69342560dc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-write-access/service.rb @@ -0,0 +1,16 @@ +require_relative 'models' + +class UserService + def update_user + user = User.new + + # Simple write (setter method call) + user.name = "Alice" + + # Object write + user.address = Address.new + + # Compound assignment (operator_assignment node) + user.score += 10 + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-yard-annotations/models.rb b/gitnexus/test/fixtures/lang-resolution/ruby-yard-annotations/models.rb new file mode 100644 index 0000000000..df48a59bd5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-yard-annotations/models.rb @@ -0,0 +1,15 @@ +class UserRepo + def save + true + end + + def find_by_name(name) + true + end +end + +class User + def greet + "hello" + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-yard-annotations/service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-yard-annotations/service.rb new file mode 100644 index 0000000000..28c3c9abaa --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-yard-annotations/service.rb @@ -0,0 +1,11 @@ +require_relative './models' + +class UserService + # @param repo [UserRepo] the repository + # @param user [User] the user to create + # @return [Boolean] + def create(repo, user) + repo.save + user.greet + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-yard-generics/models.rb b/gitnexus/test/fixtures/lang-resolution/ruby-yard-generics/models.rb new file mode 100644 index 0000000000..a2082d0f9e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-yard-generics/models.rb @@ -0,0 +1,19 @@ +class UserRepo + def save + true + end + + def find_all + [] + end +end + +class AdminRepo + def save + true + end + + def find_all + [] + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/ruby-yard-generics/service.rb b/gitnexus/test/fixtures/lang-resolution/ruby-yard-generics/service.rb new file mode 100644 index 0000000000..5d18dda1d0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ruby-yard-generics/service.rb @@ -0,0 +1,16 @@ +require_relative './models' + +class DataService + # @param repo [UserRepo] the user repository + # @param cache [Hash<Symbol, UserRepo>] cache of repos by symbol key + def sync(repo, cache) + repo.save + repo.find_all + end + + # @param [AdminRepo] admin_repo the admin repository (alternate YARD order) + def audit(admin_repo) + admin_repo.save + admin_repo.find_all + end +end diff --git a/gitnexus/test/fixtures/lang-resolution/rust-alias-imports/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-alias-imports/src/main.rs new file mode 100644 index 0000000000..b53dc15611 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-alias-imports/src/main.rs @@ -0,0 +1,11 @@ +mod models; + +use crate::models::User as U; +use crate::models::Repo as R; + +fn main() { + let u = U { name: String::from("alice") }; + let r = R { url: String::from("https://example.com") }; + u.save(); + r.persist(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-alias-imports/src/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-alias-imports/src/models.rs new file mode 100644 index 0000000000..8203ebbdf1 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-alias-imports/src/models.rs @@ -0,0 +1,19 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) -> bool { + true + } +} + +pub struct Repo { + pub url: String, +} + +impl Repo { + pub fn persist(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/main.rs new file mode 100644 index 0000000000..03142f9a79 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/main.rs @@ -0,0 +1,8 @@ +mod models; +mod other; +mod services; + +fn main() { + let h = services::create_handler(); + h.handle(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/models/handler.rs b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/models/handler.rs new file mode 100644 index 0000000000..4e666bbf15 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/models/handler.rs @@ -0,0 +1,7 @@ +pub struct Handler { + pub name: String, +} + +impl Handler { + pub fn handle(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/models/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/models/mod.rs new file mode 100644 index 0000000000..ee6e88bd27 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/models/mod.rs @@ -0,0 +1,2 @@ +pub mod handler; +pub use handler::Handler; diff --git a/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/other/handler.rs b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/other/handler.rs new file mode 100644 index 0000000000..bba33505f2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/other/handler.rs @@ -0,0 +1,7 @@ +pub struct Handler { + pub id: u32, +} + +impl Handler { + pub fn process(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/other/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/other/mod.rs new file mode 100644 index 0000000000..ee6e88bd27 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/other/mod.rs @@ -0,0 +1,2 @@ +pub mod handler; +pub use handler::Handler; diff --git a/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/services/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/services/mod.rs new file mode 100644 index 0000000000..e137dea4ed --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-ambiguous/src/services/mod.rs @@ -0,0 +1,5 @@ +use crate::models::Handler; + +pub fn create_handler() -> Handler { + Handler { name: String::new() } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/main.rs new file mode 100644 index 0000000000..dd98690ed4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/main.rs @@ -0,0 +1,19 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +fn get_user() -> User { User } +fn get_repo() -> Repo { Repo } + +fn process_entities() { + let u: User = get_user(); + let alias = u; + alias.save(); + + let r: Repo = get_repo(); + let r_alias = r; + r_alias.save(); +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/repo.rs new file mode 100644 index 0000000000..18a7862885 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/repo.rs @@ -0,0 +1,7 @@ +pub struct Repo; + +impl Repo { + pub fn save(&self) -> bool { + false + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/user.rs new file mode 100644 index 0000000000..59bcfd2b23 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-assignment-chain/src/user.rs @@ -0,0 +1,7 @@ +pub struct User; + +impl User { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/main.rs new file mode 100644 index 0000000000..7e853beab3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/main.rs @@ -0,0 +1,23 @@ +mod user; +mod repo; + +use user::User; +use repo::Repo; + +async fn get_user() -> User { + User { name: String::from("alice") } +} + +async fn get_repo() -> Repo { + Repo { name: String::from("main") } +} + +async fn process_user() { + let user = get_user().await; + user.save(); +} + +async fn process_repo() { + let repo = get_repo().await; + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/repo.rs new file mode 100644 index 0000000000..76156e15df --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/repo.rs @@ -0,0 +1,9 @@ +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/user.rs new file mode 100644 index 0000000000..31e047e0e2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-async-binding/src/user.rs @@ -0,0 +1,9 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-calls/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-calls/src/main.rs new file mode 100644 index 0000000000..0159caf70c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-calls/src/main.rs @@ -0,0 +1,9 @@ +mod onearg; +mod zeroarg; + +use crate::onearg::write_audit; +use crate::zeroarg::write_audit as zero_write_audit; + +fn main() { + let _ = write_audit("hello"); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-calls/src/onearg/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-calls/src/onearg/mod.rs new file mode 100644 index 0000000000..a04f597ab8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-calls/src/onearg/mod.rs @@ -0,0 +1,3 @@ +pub fn write_audit(message: &str) -> &str { + message +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-calls/src/zeroarg/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-calls/src/zeroarg/mod.rs new file mode 100644 index 0000000000..8ab279e454 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-calls/src/zeroarg/mod.rs @@ -0,0 +1,3 @@ +pub fn write_audit() -> &'static str { + "zero" +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/main.rs new file mode 100644 index 0000000000..de26632de7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/main.rs @@ -0,0 +1,16 @@ +mod models; + +use models::user::User; + +struct UserService; + +impl UserService { + fn get_user(&self) -> User { + User { name: String::from("alice") } + } +} + +fn process_user() { + let svc = UserService; + svc.get_user().save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/mod.rs new file mode 100644 index 0000000000..5122f5996c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/mod.rs @@ -0,0 +1,2 @@ +pub mod user; +pub mod repo; diff --git a/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/repo.rs new file mode 100644 index 0000000000..76156e15df --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/repo.rs @@ -0,0 +1,9 @@ +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/user.rs new file mode 100644 index 0000000000..31e047e0e2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-chain-call/src/models/user.rs @@ -0,0 +1,9 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/main.rs new file mode 100644 index 0000000000..c32a3724c3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/main.rs @@ -0,0 +1,13 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +fn process_entities() { + let user = User::new(); + let repo = Repo::new(); + user.save(); + repo.save(); +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/repo.rs new file mode 100644 index 0000000000..da880dd959 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/repo.rs @@ -0,0 +1,11 @@ +pub struct Repo; + +impl Repo { + pub fn new() -> Self { + Repo + } + + pub fn save(&self) -> bool { + false + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/user.rs new file mode 100644 index 0000000000..e4203f981d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-constructor-type-inference/src/user.rs @@ -0,0 +1,11 @@ +pub struct User; + +impl User { + pub fn new() -> Self { + User + } + + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-deep-field-chain/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-deep-field-chain/models.rs new file mode 100644 index 0000000000..03f26eda1c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-deep-field-chain/models.rs @@ -0,0 +1,25 @@ +pub struct City { + pub zip_code: String, +} + +impl City { + pub fn get_name(&self) -> &str { + "city" + } +} + +pub struct Address { + pub city: City, + pub street: String, +} + +impl Address { + pub fn save(&self) { + // persist address + } +} + +pub struct User { + pub name: String, + pub address: Address, +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-deep-field-chain/service.rs b/gitnexus/test/fixtures/lang-resolution/rust-deep-field-chain/service.rs new file mode 100644 index 0000000000..005e90695d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-deep-field-chain/service.rs @@ -0,0 +1,6 @@ +use crate::models::{User, Address, City}; + +fn process_user(user: &User) { + user.address.save(); + user.address.city.get_name(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/main.rs new file mode 100644 index 0000000000..f9bb13366b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/main.rs @@ -0,0 +1,20 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +fn process_with_new() { + let user = User::new(); + let repo = Repo::new(); + user.save(); + repo.save(); +} + +fn process_with_default() { + let user = User::default(); + let repo = Repo::default(); + user.save(); + repo.save(); +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/repo.rs new file mode 100644 index 0000000000..30093cee05 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/repo.rs @@ -0,0 +1,17 @@ +pub struct Repo; + +impl Repo { + pub fn new() -> Self { + Repo + } + + pub fn save(&self) -> bool { + true + } +} + +impl Default for Repo { + fn default() -> Self { + Repo + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/user.rs new file mode 100644 index 0000000000..8c9e99fb32 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-default-constructor/src/user.rs @@ -0,0 +1,17 @@ +pub struct User; + +impl User { + pub fn new() -> Self { + User + } + + pub fn save(&self) -> bool { + true + } +} + +impl Default for User { + fn default() -> Self { + User + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/error.rs b/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/error.rs new file mode 100644 index 0000000000..de712550dd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/error.rs @@ -0,0 +1,7 @@ +pub struct AppError { + pub code: i32, +} + +impl AppError { + pub fn report(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/main.rs new file mode 100644 index 0000000000..7c63893b5e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/main.rs @@ -0,0 +1,18 @@ +mod user; +mod error; +use crate::user::User; +use crate::error::AppError; + +fn handle_err(res: Result<User, AppError>) { + if let Err(e) = res { + e.report(); + } +} + +fn handle_ok(res: Result<User, AppError>) { + if let Ok(user) = res { + user.save(); + } +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/repo.rs new file mode 100644 index 0000000000..bc1ad22b0b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/repo.rs @@ -0,0 +1,7 @@ +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/user.rs new file mode 100644 index 0000000000..706b245583 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-err-unwrap/src/user.rs @@ -0,0 +1,7 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-field-types/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-field-types/models.rs new file mode 100644 index 0000000000..3d9f571ffd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-field-types/models.rs @@ -0,0 +1,20 @@ +pub struct Address { + pub city: String, +} + +impl Address { + pub fn save(&self) { + // persist address + } +} + +pub struct User { + pub name: String, + pub address: Address, +} + +impl User { + pub fn greet(&self) -> &str { + &self.name + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-field-types/service.rs b/gitnexus/test/fixtures/lang-resolution/rust-field-types/service.rs new file mode 100644 index 0000000000..be2ae66f79 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-field-types/service.rs @@ -0,0 +1,5 @@ +use crate::models::{User, Address}; + +fn process_user(user: &User) { + user.address.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/main.rs new file mode 100644 index 0000000000..f87db8f4bc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/main.rs @@ -0,0 +1,18 @@ +mod user; +mod repo; +use crate::user::get_users; +use crate::repo::get_repos; + +fn process_users() { + for user in get_users() { + user.save(); + } +} + +fn process_repos() { + for repo in get_repos() { + repo.save(); + } +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/repo.rs new file mode 100644 index 0000000000..4ef7eb0720 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/repo.rs @@ -0,0 +1,11 @@ +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) {} +} + +pub fn get_repos() -> Vec<Repo> { + vec![Repo { name: "main".into() }] +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/user.rs new file mode 100644 index 0000000000..5d53d6b34f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-for-call-expr/src/user.rs @@ -0,0 +1,11 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) {} +} + +pub fn get_users() -> Vec<User> { + vec![User { name: "alice".into() }] +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/main.rs new file mode 100644 index 0000000000..b09908fe22 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/main.rs @@ -0,0 +1,18 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +fn process_users(users: Vec<User>) { + for user in &users { + user.save(); + } +} + +fn process_repos(repos: Vec<Repo>) { + for repo in &repos { + repo.save(); + } +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/repo.rs new file mode 100644 index 0000000000..bc1ad22b0b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/repo.rs @@ -0,0 +1,7 @@ +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/user.rs new file mode 100644 index 0000000000..706b245583 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-for-loop/src/user.rs @@ -0,0 +1,7 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-grouped-imports/src/helpers/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-grouped-imports/src/helpers/mod.rs new file mode 100644 index 0000000000..fa1fcc54ba --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-grouped-imports/src/helpers/mod.rs @@ -0,0 +1,7 @@ +pub fn format_name(name: &str) -> String { + format!("Hello, {}", name) +} + +pub fn validate_email(email: &str) -> bool { + email.contains('@') +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-grouped-imports/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-grouped-imports/src/main.rs new file mode 100644 index 0000000000..f60a122eec --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-grouped-imports/src/main.rs @@ -0,0 +1,9 @@ +mod helpers; + +use crate::helpers::{format_name, validate_email}; + +fn main() { + let name = format_name("world"); + let valid = validate_email("test@example.com"); + println!("{} {}", name, valid); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/mod.rs new file mode 100644 index 0000000000..4e7b9dc71e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/mod.rs @@ -0,0 +1 @@ +// Placeholder — actual module structure is in src/ diff --git a/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/repo.rs new file mode 100644 index 0000000000..7ed292fe72 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/repo.rs @@ -0,0 +1 @@ +// Placeholder — actual Repo definition is in src/repo.rs diff --git a/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/user.rs new file mode 100644 index 0000000000..d6e967f0dd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/models/user.rs @@ -0,0 +1 @@ +// Placeholder — actual User definition is in src/user.rs diff --git a/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/main.rs new file mode 100644 index 0000000000..548b7628c8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/main.rs @@ -0,0 +1,11 @@ +mod user; +mod repo; +use crate::user::User; + +fn process(opt: Option<User>) { + if let Some(user) = opt { + user.save(); + } +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/repo.rs new file mode 100644 index 0000000000..bc1ad22b0b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/repo.rs @@ -0,0 +1,7 @@ +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/user.rs new file mode 100644 index 0000000000..706b245583 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-if-let-unwrap/src/user.rs @@ -0,0 +1,7 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-if-let/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-if-let/main.rs new file mode 100644 index 0000000000..73c49f715f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-if-let/main.rs @@ -0,0 +1,24 @@ +mod models; +use models::{User, Config}; + +fn get_user() -> User { + User { name: "alice".to_string(), age: 30 } +} + +fn process_if_let() { + // captured_pattern: user @ User { .. } — binds 'user' with type 'User' + if let user @ User { .. } = get_user() { + user.save(); + } +} + +fn process_while_let() { + // captured_pattern inside while-let + while let cfg @ Config { .. } = get_config() { + cfg.validate(); + } +} + +fn get_config() -> Config { + Config { debug: true } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-if-let/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-if-let/models.rs new file mode 100644 index 0000000000..449554d1b9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-if-let/models.rs @@ -0,0 +1,18 @@ +pub struct User { + pub name: String, + pub age: u32, +} + +impl User { + pub fn save(&self) {} +} + +pub struct Config { + pub debug: bool, +} + +impl Config { + pub fn validate(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/main.rs new file mode 100644 index 0000000000..e40a04da5d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/main.rs @@ -0,0 +1,18 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +fn process_users(users: Vec<User>) { + for user in users.iter() { + user.save(); + } +} + +fn process_repos(repos: Vec<Repo>) { + for repo in repos.into_iter() { + repo.save(); + } +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/repo.rs new file mode 100644 index 0000000000..bc1ad22b0b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/repo.rs @@ -0,0 +1,7 @@ +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/user.rs new file mode 100644 index 0000000000..706b245583 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-iter-for-loop/src/user.rs @@ -0,0 +1,7 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/Cargo.toml b/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/Cargo.toml new file mode 100644 index 0000000000..5b74cf8f8e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/Cargo.toml @@ -0,0 +1,4 @@ +[package] +name = "rust-local-shadow" +version = "0.1.0" +edition = "2021" diff --git a/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/src/main.rs new file mode 100644 index 0000000000..a5fc97b9eb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/src/main.rs @@ -0,0 +1,15 @@ +mod utils; +use utils::save; + +// Local function shadows imported save +fn save(data: &str) { + println!("local save: {}", data); +} + +fn run() { + save("test"); +} + +fn main() { + run(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/src/utils.rs b/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/src/utils.rs new file mode 100644 index 0000000000..6bf79060e4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-local-shadow/src/utils.rs @@ -0,0 +1,3 @@ +pub fn save(data: &str) { + println!("utils save: {}", data); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/main.rs new file mode 100644 index 0000000000..7c40df44bf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/main.rs @@ -0,0 +1,19 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +fn process(opt: Option<User>) { + match opt { + Some(user) => user.save(), + None => {}, + } +} + +fn check(res: Result<Repo, String>) { + if let Ok(repo) = res { + repo.save(); + } +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/repo.rs new file mode 100644 index 0000000000..bc1ad22b0b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/repo.rs @@ -0,0 +1,7 @@ +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/user.rs new file mode 100644 index 0000000000..706b245583 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-match-unwrap/src/user.rs @@ -0,0 +1,7 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-member-calls/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-member-calls/src/main.rs new file mode 100644 index 0000000000..7fc46f522e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-member-calls/src/main.rs @@ -0,0 +1,9 @@ +mod user; +use crate::user::User; + +fn process_user() -> bool { + let u = User; + u.save() +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-member-calls/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-member-calls/src/user.rs new file mode 100644 index 0000000000..59bcfd2b23 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-member-calls/src/user.rs @@ -0,0 +1,7 @@ +pub struct User; + +impl User { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/main.rs new file mode 100644 index 0000000000..c94c16a094 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/main.rs @@ -0,0 +1,21 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +fn find_user() -> Option<User> { + Some(User) +} + +fn find_repo() -> Option<Repo> { + Some(Repo) +} + +fn process_entities() { + let user: Option<User> = find_user(); + user.unwrap().save(); + let repo: Option<Repo> = find_repo(); + repo.unwrap().save(); +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/repo.rs new file mode 100644 index 0000000000..18a7862885 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/repo.rs @@ -0,0 +1,7 @@ +pub struct Repo; + +impl Repo { + pub fn save(&self) -> bool { + false + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/user.rs new file mode 100644 index 0000000000..59bcfd2b23 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-nullable-receiver/src/user.rs @@ -0,0 +1,7 @@ +pub struct User; + +impl User { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/main.rs new file mode 100644 index 0000000000..376d3ddaaf --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/main.rs @@ -0,0 +1,17 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +// Tests that Option<User> unwraps to User in TypeEnv, +// and assignment chain from Option-typed source resolves correctly. +fn process_entities() { + let opt: Option<User> = Some(User); + let alias = opt; + alias.save(); + + let repo: Repo = Repo; + repo.save(); +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/repo.rs new file mode 100644 index 0000000000..dc20dc4055 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/repo.rs @@ -0,0 +1,5 @@ +pub struct Repo; + +impl Repo { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/user.rs new file mode 100644 index 0000000000..e58906565d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-option-receiver/src/user.rs @@ -0,0 +1,5 @@ +pub struct User; + +impl User { + pub fn save(&self) {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/lib.rs b/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/lib.rs new file mode 100644 index 0000000000..09298bff66 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/lib.rs @@ -0,0 +1,2 @@ +pub mod serializable; +pub mod user; diff --git a/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/serializable.rs b/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/serializable.rs new file mode 100644 index 0000000000..ddf412263c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/serializable.rs @@ -0,0 +1,3 @@ +pub trait Serializable { + fn serialize(&self) -> String; +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/user.rs new file mode 100644 index 0000000000..3b41fe70d5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-parent-resolution/src/user.rs @@ -0,0 +1,9 @@ +use crate::serializable::Serializable; + +pub struct User; + +impl Serializable for User { + fn serialize(&self) -> String { + String::new() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/main.rs new file mode 100644 index 0000000000..ffb8cb32c8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/main.rs @@ -0,0 +1,13 @@ +mod user; +mod repo; +use crate::user::User; +use crate::repo::Repo; + +fn process_entities() { + let user: User = User; + let repo: Repo = Repo; + user.save(); + repo.save(); +} + +fn main() {} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/repo.rs new file mode 100644 index 0000000000..18a7862885 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/repo.rs @@ -0,0 +1,7 @@ +pub struct Repo; + +impl Repo { + pub fn save(&self) -> bool { + false + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/user.rs new file mode 100644 index 0000000000..59bcfd2b23 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-receiver-resolution/src/user.rs @@ -0,0 +1,7 @@ +pub struct User; + +impl User { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/main.rs new file mode 100644 index 0000000000..2aa60c957a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/main.rs @@ -0,0 +1,7 @@ +mod models; +use crate::models::Handler; + +fn main() { + let h = Handler { name: String::from("test") }; + h.process(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/models/handler.rs b/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/models/handler.rs new file mode 100644 index 0000000000..0eb1e60c53 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/models/handler.rs @@ -0,0 +1,9 @@ +pub struct Handler { + pub name: String, +} + +impl Handler { + pub fn process(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/models/mod.rs b/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/models/mod.rs new file mode 100644 index 0000000000..ee6e88bd27 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-reexport-chain/src/models/mod.rs @@ -0,0 +1,2 @@ +pub mod handler; +pub use handler::Handler; diff --git a/gitnexus/test/fixtures/lang-resolution/rust-return-type-inference/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-return-type-inference/src/main.rs new file mode 100644 index 0000000000..984621603e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-return-type-inference/src/main.rs @@ -0,0 +1,21 @@ +mod models; + +use models::{User, Repo}; + +fn get_user() -> User { + User { name: String::from("alice") } +} + +fn get_repo() -> Repo { + Repo { name: String::from("main") } +} + +fn process_user() { + let user = get_user(); + user.save(); +} + +fn process_repo() { + let repo = get_repo(); + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-return-type-inference/src/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-return-type-inference/src/models.rs new file mode 100644 index 0000000000..05659ee6c9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-return-type-inference/src/models.rs @@ -0,0 +1,19 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) -> bool { + true + } +} + +pub struct Repo { + pub name: String, +} + +impl Repo { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-return-type/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-return-type/src/main.rs new file mode 100644 index 0000000000..f4f40ec5a8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-return-type/src/main.rs @@ -0,0 +1,7 @@ +mod models; +use crate::models::get_user; + +fn main() { + let user = get_user("alice"); + user.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-return-type/src/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-return-type/src/models.rs new file mode 100644 index 0000000000..85ce57013f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-return-type/src/models.rs @@ -0,0 +1,11 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) {} +} + +pub fn get_user(name: &str) -> User { + User { name: name.to_string() } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-self-struct-literal/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-self-struct-literal/main.rs new file mode 100644 index 0000000000..5cae674943 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-self-struct-literal/main.rs @@ -0,0 +1,7 @@ +mod models; +use models::User; + +fn main() { + let user = User::blank(); + user.greet(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-self-struct-literal/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-self-struct-literal/models.rs new file mode 100644 index 0000000000..aa76c1e493 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-self-struct-literal/models.rs @@ -0,0 +1,19 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn blank() -> Self { + let fresh = Self { name: String::new() }; + fresh.validate(); + fresh + } + + pub fn validate(&self) -> bool { + !self.name.is_empty() + } + + pub fn greet(&self) -> String { + format!("Hello, {}", self.name) + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-self-this-resolution/src/repo.rs b/gitnexus/test/fixtures/lang-resolution/rust-self-this-resolution/src/repo.rs new file mode 100644 index 0000000000..318a2605d3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-self-this-resolution/src/repo.rs @@ -0,0 +1,5 @@ +pub struct Repo; + +impl Repo { + pub fn save(&self) -> bool { true } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-self-this-resolution/src/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-self-this-resolution/src/user.rs new file mode 100644 index 0000000000..117be7c67d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-self-this-resolution/src/user.rs @@ -0,0 +1,8 @@ +pub struct User; + +impl User { + pub fn save(&self) -> bool { true } + pub fn process(&self) { + self.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-struct-literal-inference/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-struct-literal-inference/main.rs new file mode 100644 index 0000000000..5086cb560d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-struct-literal-inference/main.rs @@ -0,0 +1,10 @@ +mod models; +use models::{User, Config}; + +fn main() { + let user = User { name: "alice".to_string(), age: 30 }; + user.save(); + + let config = Config { debug: true }; + config.validate(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-struct-literal-inference/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-struct-literal-inference/models.rs new file mode 100644 index 0000000000..378ef8ff80 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-struct-literal-inference/models.rs @@ -0,0 +1,21 @@ +pub struct User { + pub name: String, + pub age: u32, +} + +impl User { + pub fn save(&self) {} + pub fn greet(&self) -> String { + format!("Hello, {}", self.name) + } +} + +pub struct Config { + pub debug: bool, +} + +impl Config { + pub fn validate(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-struct-literals/app.rs b/gitnexus/test/fixtures/lang-resolution/rust-struct-literals/app.rs new file mode 100644 index 0000000000..df112b8c8b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-struct-literals/app.rs @@ -0,0 +1,7 @@ +mod user; +use user::User; + +fn process_user(name: String) { + let user = User { name }; + user.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-struct-literals/user.rs b/gitnexus/test/fixtures/lang-resolution/rust-struct-literals/user.rs new file mode 100644 index 0000000000..31e047e0e2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-struct-literals/user.rs @@ -0,0 +1,9 @@ +pub struct User { + pub name: String, +} + +impl User { + pub fn save(&self) -> bool { + true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-traits/src/impls/button.rs b/gitnexus/test/fixtures/lang-resolution/rust-traits/src/impls/button.rs new file mode 100644 index 0000000000..37589863a0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-traits/src/impls/button.rs @@ -0,0 +1,25 @@ +use crate::traits::{Drawable, Clickable}; + +pub struct Button { + label: String, + enabled: bool, +} + +impl Drawable for Button { + fn draw(&self) { + println!("{}", self.label); + } + + fn resize(&self, width: u32, height: u32) { + } +} + +impl Clickable for Button { + fn on_click(&self) { + println!("clicked"); + } + + fn is_enabled(&self) -> bool { + self.enabled + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-traits/src/main.rs b/gitnexus/test/fixtures/lang-resolution/rust-traits/src/main.rs new file mode 100644 index 0000000000..0970ca4ea4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-traits/src/main.rs @@ -0,0 +1,8 @@ +mod traits; +mod impls; + +use crate::impls::button::Button; + +fn main() { + let btn = Button { label: String::from("OK"), enabled: true }; +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-traits/src/traits/clickable.rs b/gitnexus/test/fixtures/lang-resolution/rust-traits/src/traits/clickable.rs new file mode 100644 index 0000000000..0fdd649252 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-traits/src/traits/clickable.rs @@ -0,0 +1,4 @@ +pub trait Clickable { + fn on_click(&self); + fn is_enabled(&self) -> bool; +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-traits/src/traits/drawable.rs b/gitnexus/test/fixtures/lang-resolution/rust-traits/src/traits/drawable.rs new file mode 100644 index 0000000000..e023eaf436 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-traits/src/traits/drawable.rs @@ -0,0 +1,4 @@ +pub trait Drawable { + fn draw(&self); + fn resize(&self, width: u32, height: u32); +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-write-access/models.rs b/gitnexus/test/fixtures/lang-resolution/rust-write-access/models.rs new file mode 100644 index 0000000000..5971e17807 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-write-access/models.rs @@ -0,0 +1,9 @@ +pub struct Address { + pub city: String, +} + +pub struct User { + pub name: String, + pub address: Address, + pub score: i32, +} diff --git a/gitnexus/test/fixtures/lang-resolution/rust-write-access/service.rs b/gitnexus/test/fixtures/lang-resolution/rust-write-access/service.rs new file mode 100644 index 0000000000..1c6326b8f3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/rust-write-access/service.rs @@ -0,0 +1,7 @@ +use crate::models::{User, Address}; + +fn update_user(user: &mut User) { + user.name = String::from("Alice"); + user.address = Address { city: String::from("NYC") }; + user.score += 10; +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Models/Repo.swift b/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Models/Repo.swift new file mode 100644 index 0000000000..ebbdce0040 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Models/Repo.swift @@ -0,0 +1,11 @@ +class Repo { + let dbName: String + + init(dbName: String) { + self.dbName = dbName + } + + func save() -> Bool { + return false + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Models/User.swift b/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Models/User.swift new file mode 100644 index 0000000000..bdc4ec0ef4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Models/User.swift @@ -0,0 +1,11 @@ +class User { + let name: String + + init(name: String) { + self.name = name + } + + func save() -> Bool { + return true + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Services/App.swift b/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Services/App.swift new file mode 100644 index 0000000000..040c3a973c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-constructor-type-inference/Services/App.swift @@ -0,0 +1,8 @@ +import Models + +func processEntities() { + let user = User(name: "alice") + let repo = Repo(dbName: "maindb") + user.save() + repo.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-init-cross-file/User.swift b/gitnexus/test/fixtures/lang-resolution/swift-init-cross-file/User.swift new file mode 100644 index 0000000000..ba74a89d8a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-init-cross-file/User.swift @@ -0,0 +1,12 @@ +class User { + var name: String + + init(name: String) { + self.name = name + } + + func save() {} + func greet() -> String { + return "Hello, \(name)" + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-init-cross-file/main.swift b/gitnexus/test/fixtures/lang-resolution/swift-init-cross-file/main.swift new file mode 100644 index 0000000000..79675258cb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-init-cross-file/main.swift @@ -0,0 +1,5 @@ +func main() { + let user = User.init(name: "alice") + user.save() + user.greet() +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/BaseModel.swift b/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/BaseModel.swift new file mode 100644 index 0000000000..c91513dffc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/BaseModel.swift @@ -0,0 +1,3 @@ +class BaseModel { + func save() -> Bool { return true } +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/Serializable.swift b/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/Serializable.swift new file mode 100644 index 0000000000..fd8c83b067 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/Serializable.swift @@ -0,0 +1,3 @@ +protocol Serializable { + func serialize() -> String +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/User.swift b/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/User.swift new file mode 100644 index 0000000000..c4616473ce --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-parent-resolution/Sources/Models/User.swift @@ -0,0 +1,3 @@ +class User: BaseModel, Serializable { + func serialize() -> String { return "" } +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-return-type-inference/App.swift b/gitnexus/test/fixtures/lang-resolution/swift-return-type-inference/App.swift new file mode 100644 index 0000000000..5893a35c3f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-return-type-inference/App.swift @@ -0,0 +1,17 @@ +func getUser() -> User { + return User(name: "alice") +} + +func getRepo() -> Repo { + return Repo(name: "main") +} + +func processUser() { + let user = getUser() + user.save() +} + +func processRepo() { + let repo = getRepo() + repo.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-return-type-inference/Models.swift b/gitnexus/test/fixtures/lang-resolution/swift-return-type-inference/Models.swift new file mode 100644 index 0000000000..a849549902 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-return-type-inference/Models.swift @@ -0,0 +1,11 @@ +class User { + var name: String + init(name: String) { self.name = name } + func save() -> Bool { return true } +} + +class Repo { + var name: String + init(name: String) { self.name = name } + func save() -> Bool { return true } +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-return-type/App.swift b/gitnexus/test/fixtures/lang-resolution/swift-return-type/App.swift new file mode 100644 index 0000000000..edf1600d96 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-return-type/App.swift @@ -0,0 +1,4 @@ +func processUser() { + let user = getUser(name: "alice") + user.save() +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-return-type/Models.swift b/gitnexus/test/fixtures/lang-resolution/swift-return-type/Models.swift new file mode 100644 index 0000000000..69a9139c41 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-return-type/Models.swift @@ -0,0 +1,13 @@ +class User { + let name: String + + init(name: String) { + self.name = name + } + + func save() {} +} + +func getUser(name: String) -> User { + return User(name: name) +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-self-this-resolution/Sources/Models/Repo.swift b/gitnexus/test/fixtures/lang-resolution/swift-self-this-resolution/Sources/Models/Repo.swift new file mode 100644 index 0000000000..3d6901a654 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-self-this-resolution/Sources/Models/Repo.swift @@ -0,0 +1,3 @@ +class Repo { + func save() -> Bool { return true } +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-self-this-resolution/Sources/Models/User.swift b/gitnexus/test/fixtures/lang-resolution/swift-self-this-resolution/Sources/Models/User.swift new file mode 100644 index 0000000000..e30c21f083 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-self-this-resolution/Sources/Models/User.swift @@ -0,0 +1,6 @@ +class User { + func save() -> Bool { return true } + func process() { + self.save() + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/app.ts b/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/app.ts new file mode 100644 index 0000000000..d8a84d5582 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/app.ts @@ -0,0 +1,15 @@ +import { User } from './user'; +import { Repo } from './repo'; + +function getUser(): User { return new User(); } +function getRepo(): Repo { return new Repo(); } + +export function processEntities(): void { + const u: User = getUser(); + const alias = u; + alias.save(); + + const r: Repo = getRepo(); + const rAlias = r; + rAlias.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/repo.ts new file mode 100644 index 0000000000..19631246b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/repo.ts @@ -0,0 +1,5 @@ +export class Repo { + save(): boolean { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/user.ts b/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/user.ts new file mode 100644 index 0000000000..e2af97ca77 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-assignment-chain/src/user.ts @@ -0,0 +1,5 @@ +export class User { + save(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/app.ts b/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/app.ts new file mode 100644 index 0000000000..c1d029e2c2 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/app.ts @@ -0,0 +1,19 @@ +import { User } from './models/user'; +import { Repo } from './models/repo'; + +class UserService { + private users: User[] = []; + private repos: Map<string, Repo> = new Map(); + + processUsers() { + for (const user of this.users) { + user.save(); + } + } + + processRepos() { + for (const repo of this.repos.values()) { + repo.save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/models/repo.ts b/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/models/repo.ts new file mode 100644 index 0000000000..ed84b12ff3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/models/repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/models/user.ts b/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/models/user.ts new file mode 100644 index 0000000000..a464054e0c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-class-field-foreach/models/user.ts @@ -0,0 +1,3 @@ +export class User { + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-deep-field-chain/models.ts b/gitnexus/test/fixtures/lang-resolution/ts-deep-field-chain/models.ts new file mode 100644 index 0000000000..b28b0a6ee5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-deep-field-chain/models.ts @@ -0,0 +1,25 @@ +export class City { + zipCode: string; + + getName(): string { + return 'city'; + } +} + +export class Address { + city: City; + street: string; + + save(): void { + // persist address + } +} + +export class User { + name: string; + address: Address; + + greet(): string { + return this.name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-deep-field-chain/service.ts b/gitnexus/test/fixtures/lang-resolution/ts-deep-field-chain/service.ts new file mode 100644 index 0000000000..bf561827d9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-deep-field-chain/service.ts @@ -0,0 +1,9 @@ +import { User } from './models'; + +function processUser(user: User) { + // 2-level chain: user.address → Address, then .save() → Address#save + user.address.save(); + + // 3-level chain: user.address → Address, .city → City, .getName() → City#getName + user.address.city.getName(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/address.ts b/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/address.ts new file mode 100644 index 0000000000..68559457c5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/address.ts @@ -0,0 +1,7 @@ +export class Address { + city: string; + + save(): void { + // persist address + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/service.ts b/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/service.ts new file mode 100644 index 0000000000..4c78a3fa23 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/service.ts @@ -0,0 +1,7 @@ +import { User } from './user'; + +function processUser(user: User) { + // Field-access chain: user.address resolves to Address, then .save() must resolve + // to Address#save (NOT User#save) — only lookupFieldByOwner can disambiguate. + user.address.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/user.ts b/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/user.ts new file mode 100644 index 0000000000..6386ecbf78 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-field-type-disambig/user.ts @@ -0,0 +1,10 @@ +import { Address } from './address'; + +export class User { + name: string; + address: Address; + + save(): void { + // persist user + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-mixed-chain/models.ts b/gitnexus/test/fixtures/lang-resolution/ts-mixed-chain/models.ts new file mode 100644 index 0000000000..baeb43deb3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-mixed-chain/models.ts @@ -0,0 +1,27 @@ +export class City { + getName(): string { + return 'city'; + } +} + +export class Address { + city: City; + + save(): void { + // persist address + } +} + +export class User { + address: Address; + + getAddress(): Address { + return this.address; + } +} + +export class UserService { + getUser(): User { + return new User(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-mixed-chain/service.ts b/gitnexus/test/fixtures/lang-resolution/ts-mixed-chain/service.ts new file mode 100644 index 0000000000..227d87fbb7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-mixed-chain/service.ts @@ -0,0 +1,11 @@ +import { User, UserService } from './models'; + +function processWithService(svc: UserService) { + // call → field → call: svc.getUser().address.save() + svc.getUser().address.save(); +} + +function processWithUser(user: User) { + // field → call → call: user.getAddress().city.getName() + user.getAddress().city.getName(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/app.ts b/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/app.ts new file mode 100644 index 0000000000..81e72c0322 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/app.ts @@ -0,0 +1,22 @@ +import { User } from './user'; +import { Repo } from './repo'; + +function getUser(): User { return new User(); } +function getRepo(): Repo { return new Repo(); } + +// Multi-hop forward-declared chain: a → b → c (source order) +// All three should resolve because the post-walk pass processes in order. +export function multiHopForward(): void { + const a: User = getUser(); + const b = a; + const c = b; + c.save(); +} + +// Multi-hop with Repo to prove disambiguation +export function multiHopRepo(): void { + const a: Repo = getRepo(); + const b = a; + const c = b; + c.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/repo.ts new file mode 100644 index 0000000000..19631246b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/repo.ts @@ -0,0 +1,5 @@ +export class Repo { + save(): boolean { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/user.ts b/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/user.ts new file mode 100644 index 0000000000..e2af97ca77 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-multi-hop-chain/src/user.ts @@ -0,0 +1,5 @@ +export class User { + save(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/app.ts b/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/app.ts new file mode 100644 index 0000000000..35f140d694 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/app.ts @@ -0,0 +1,27 @@ +import { User } from './user'; +import { Repo } from './repo'; + +function findUser(): User | null { return new User(); } +function findRepo(): Repo | undefined { return new Repo(); } + +// Nullable type + assignment chain: the nullable union must be stripped +// before the alias can resolve to User. +export function nullableChainUser(): void { + const u: User | null = findUser(); + const alias = u; + alias.save(); +} + +// Same pattern with Repo | undefined +export function nullableChainRepo(): void { + const r: Repo | undefined = findRepo(); + const alias = r; + alias.save(); +} + +// Triple nullable: User | null | undefined → still User +export function tripleNullable(): void { + const u: User | null | undefined = findUser(); + const alias = u; + alias.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/repo.ts new file mode 100644 index 0000000000..19631246b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/repo.ts @@ -0,0 +1,5 @@ +export class Repo { + save(): boolean { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/user.ts b/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/user.ts new file mode 100644 index 0000000000..e2af97ca77 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-nullable-chain/src/user.ts @@ -0,0 +1,5 @@ +export class User { + save(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/app.ts b/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/app.ts new file mode 100644 index 0000000000..a6d0f80285 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/app.ts @@ -0,0 +1,12 @@ +import { User } from './user'; +import { Repo } from './repo'; + +export function processEntities(): void { + const user: User | null = new User(); + const repo: Repo | undefined = new Repo(); + + // Optional chain calls — receiver should still resolve + user?.save(); + user?.greet('hello'); + repo?.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/repo.ts new file mode 100644 index 0000000000..19631246b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/repo.ts @@ -0,0 +1,5 @@ +export class Repo { + save(): boolean { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/user.ts b/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/user.ts new file mode 100644 index 0000000000..f9c5caa77a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-nullable-receiver/src/user.ts @@ -0,0 +1,9 @@ +export class User { + save(): boolean { + return true; + } + + greet(msg: string): void { + console.log(msg); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-param-property-fields/models.ts b/gitnexus/test/fixtures/lang-resolution/ts-param-property-fields/models.ts new file mode 100644 index 0000000000..513af1e9f6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-param-property-fields/models.ts @@ -0,0 +1,22 @@ +export class Address { + city: string; + + save(): void { + // persist address + } +} + +export class User { + #secret: string; + + constructor( + public name: string, + public address: Address, + ) { + this.#secret = 'hidden'; + } + + greet(): string { + return this.name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-param-property-fields/service.ts b/gitnexus/test/fixtures/lang-resolution/ts-param-property-fields/service.ts new file mode 100644 index 0000000000..e11269c12b --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-param-property-fields/service.ts @@ -0,0 +1,5 @@ +import { User } from './models'; + +function processUser(user: User) { + user.address.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/app.ts b/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/app.ts new file mode 100644 index 0000000000..a7a0ea41a5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/app.ts @@ -0,0 +1,14 @@ +import { User } from './models/user'; +import { Repo } from './models/repo'; + +function processUsers(users: readonly User[]) { + for (const user of users) { + user.save(); + } +} + +function processRepos(repos: readonly Repo[]) { + for (const repo of repos) { + repo.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/models/repo.ts b/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/models/repo.ts new file mode 100644 index 0000000000..ed84b12ff3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/models/repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/models/user.ts b/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/models/user.ts new file mode 100644 index 0000000000..a464054e0c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-readonly-foreach/models/user.ts @@ -0,0 +1,3 @@ +export class User { + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/app.ts b/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/app.ts new file mode 100644 index 0000000000..f43cda0884 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/app.ts @@ -0,0 +1,11 @@ +import { getUser, fetchUserAsync } from './service'; + +function processUser() { + const user = getUser('alice'); + user.save(); +} + +async function processUserAsync() { + const user = await fetchUserAsync('bob'); + user.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/models.ts b/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/models.ts new file mode 100644 index 0000000000..6ba96088c4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/models.ts @@ -0,0 +1,15 @@ +export class User { + name: string; + + constructor(name: string) { + this.name = name; + } + + save(): boolean { + return true; + } + + getName(): string { + return this.name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/service.ts b/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/service.ts new file mode 100644 index 0000000000..25c9d27db5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-return-type-inference/service.ts @@ -0,0 +1,9 @@ +import { User } from './models'; + +export function getUser(name: string): User { + return new User(name); +} + +export function fetchUserAsync(name: string): Promise<User> { + return Promise.resolve(new User(name)); +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-write-access/models.ts b/gitnexus/test/fixtures/lang-resolution/ts-write-access/models.ts new file mode 100644 index 0000000000..53d1e79ebd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-write-access/models.ts @@ -0,0 +1,8 @@ +export class Address { + city: string; +} + +export class User { + name: string; + address: Address; +} diff --git a/gitnexus/test/fixtures/lang-resolution/ts-write-access/service.ts b/gitnexus/test/fixtures/lang-resolution/ts-write-access/service.ts new file mode 100644 index 0000000000..4d3845af1d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/ts-write-access/service.ts @@ -0,0 +1,9 @@ +import { User, Address } from './models'; + +function updateUser(user: User) { + // Write access: user.name = "Alice" + user.name = "Alice"; + + // Write access: user.address = new Address() + user.address = new Address(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-alias-imports/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-alias-imports/src/app.ts new file mode 100644 index 0000000000..11b9b54019 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-alias-imports/src/app.ts @@ -0,0 +1,8 @@ +import { User as U, Repo as R } from './models'; + +export function main() { + const u = new U('alice'); + const r = new R('https://example.com'); + u.save(); + r.persist(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-alias-imports/src/models.ts b/gitnexus/test/fixtures/lang-resolution/typescript-alias-imports/src/models.ts new file mode 100644 index 0000000000..3b69bb04e4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-alias-imports/src/models.ts @@ -0,0 +1,19 @@ +export class User { + name: string; + constructor(name: string) { + this.name = name; + } + save(): boolean { + return true; + } +} + +export class Repo { + url: string; + constructor(url: string) { + this.url = url; + } + persist(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/logger.ts b/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/logger.ts new file mode 100644 index 0000000000..4263af297a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/logger.ts @@ -0,0 +1,7 @@ +import { ILogger } from './models'; + +export class ConsoleLogger implements ILogger { + log(message: string): void { + console.log(message); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/models.ts b/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/models.ts new file mode 100644 index 0000000000..fc690b3311 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/models.ts @@ -0,0 +1,11 @@ +export interface ILogger { + log(message: string): void; +} + +export class BaseService { + protected name: string = ''; + + getName(): string { + return this.name; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/service.ts b/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/service.ts new file mode 100644 index 0000000000..6bb6a51128 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-ambiguous/src/service.ts @@ -0,0 +1,13 @@ +import { BaseService, ILogger } from './models'; +import { ConsoleLogger } from './logger'; + +export class UserService extends BaseService implements ILogger { + log(message: string): void { + const logger = new ConsoleLogger(); + logger.log(message); + } + + getUsers(): string[] { + return []; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/one.ts b/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/one.ts new file mode 100644 index 0000000000..bd1af8d5a9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/one.ts @@ -0,0 +1,3 @@ +export function writeAudit(message: string): string { + return message; +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/service.ts b/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/service.ts new file mode 100644 index 0000000000..643b97c631 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/service.ts @@ -0,0 +1,6 @@ +import { writeAudit } from './one'; +import { writeAudit as zeroWriteAudit } from './zero'; + +export function run(): string { + return writeAudit('hello'); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/zero.ts b/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/zero.ts new file mode 100644 index 0000000000..971fa9d8d4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-calls/src/zero.ts @@ -0,0 +1,3 @@ +export function writeAudit(): string { + return 'zero'; +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/app.ts new file mode 100644 index 0000000000..70c3274b6e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/app.ts @@ -0,0 +1,10 @@ +import { User } from './user'; +import { Repo } from './repo'; + +function process() { + const user = new User() as any; + user.save(); + + const repo = new Repo()!; + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/repo.ts new file mode 100644 index 0000000000..5ff21c34a6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/user.ts new file mode 100644 index 0000000000..e79beaad6f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-cast-constructor-inference/src/user.ts @@ -0,0 +1,3 @@ +export class User { + save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/app.ts new file mode 100644 index 0000000000..4d77b4620d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/app.ts @@ -0,0 +1,6 @@ +import { UserService } from './services/UserService'; + +export function processUser(): void { + const svc = new UserService(); + svc.getUser().save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/models/Repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/models/Repo.ts new file mode 100644 index 0000000000..340937eb35 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/models/Repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/models/User.ts new file mode 100644 index 0000000000..a0a791e8e5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/models/User.ts @@ -0,0 +1,3 @@ +export class User { + save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/services/UserService.ts b/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/services/UserService.ts new file mode 100644 index 0000000000..510f536643 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-chain-call/services/UserService.ts @@ -0,0 +1,7 @@ +import { User } from '../models/User'; + +export class UserService { + getUser(): User { + return new User(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-constructor-calls/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-calls/src/app.ts new file mode 100644 index 0000000000..96e0caef25 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-calls/src/app.ts @@ -0,0 +1,6 @@ +import { User } from './user'; + +export function processUser(name: string): void { + const user = new User(name); + user.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-constructor-calls/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-calls/src/user.ts new file mode 100644 index 0000000000..0b4d5f31ec --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-calls/src/user.ts @@ -0,0 +1,9 @@ +export class User { + name: string; + constructor(name: string) { + this.name = name; + } + save(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/app.ts new file mode 100644 index 0000000000..33433b7773 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/app.ts @@ -0,0 +1,9 @@ +import { User } from './user'; +import { Repo } from './repo'; + +export function processEntities(): void { + const user = new User(); + const repo = new Repo(); + user.save(); + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/repo.ts new file mode 100644 index 0000000000..19631246b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/repo.ts @@ -0,0 +1,5 @@ +export class Repo { + save(): boolean { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/user.ts new file mode 100644 index 0000000000..e2af97ca77 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-constructor-type-inference/src/user.ts @@ -0,0 +1,5 @@ +export class User { + save(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/app.ts new file mode 100644 index 0000000000..d16ea64bbd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/app.ts @@ -0,0 +1,7 @@ +import { User } from './user'; + +function processEntries(entries: Map<string, User>) { + for (const [key, user] of entries) { + user.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/repo.ts new file mode 100644 index 0000000000..653bd2c519 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/repo.ts @@ -0,0 +1,4 @@ +export class Repo { + constructor(public name: string) {} + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/user.ts new file mode 100644 index 0000000000..a4f084b289 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-destructured-for-of/src/user.ts @@ -0,0 +1,4 @@ +export class User { + constructor(public name: string) {} + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/app.ts new file mode 100644 index 0000000000..6938f08b98 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/app.ts @@ -0,0 +1,10 @@ +import { User } from './user'; +import { Repo } from './repo'; + +function process() { + const user = new User() as unknown as any; + user.save(); + + const repo = new Repo() as unknown as object; + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/repo.ts new file mode 100644 index 0000000000..5ff21c34a6 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/user.ts new file mode 100644 index 0000000000..e79beaad6f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-double-cast-inference/src/user.ts @@ -0,0 +1,3 @@ +export class User { + save() { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/main.ts b/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/main.ts new file mode 100644 index 0000000000..330048c14a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/main.ts @@ -0,0 +1,14 @@ +import { getUsers } from './models/user'; +import { getRepos } from './models/repo'; + +function processUsers(): void { + for (const user of getUsers()) { + user.save(); + } +} + +function processRepos(): void { + for (const repo of getRepos()) { + repo.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/models/repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/models/repo.ts new file mode 100644 index 0000000000..908aaf552d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/models/repo.ts @@ -0,0 +1,9 @@ +export class Repo { + name: string; + constructor(name: string) { this.name = name; } + save(): void {} +} + +export function getRepos(): Repo[] { + return [new Repo("main")]; +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/models/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/models/user.ts new file mode 100644 index 0000000000..7f8334fbad --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-for-of-call-expr/models/user.ts @@ -0,0 +1,9 @@ +export class User { + name: string; + constructor(name: string) { this.name = name; } + save(): void {} +} + +export function getUsers(): User[] { + return [new User("alice")]; +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/Base.ts b/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/Base.ts new file mode 100644 index 0000000000..a560b7b985 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/Base.ts @@ -0,0 +1,3 @@ +export class BaseModel<T> { + save(): boolean { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/Repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/Repo.ts new file mode 100644 index 0000000000..939092cce3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/Repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save(): boolean { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/User.ts new file mode 100644 index 0000000000..ecf4abee07 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-generic-parent-resolution/src/models/User.ts @@ -0,0 +1,8 @@ +import { BaseModel } from './Base'; + +export class User extends BaseModel<string> { + save(): boolean { + super.save(); + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/app.ts new file mode 100644 index 0000000000..5b94bce5f8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/app.ts @@ -0,0 +1,7 @@ +import { User } from './user'; + +function process(x) { + if (x instanceof User) { + x.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/repo.ts new file mode 100644 index 0000000000..653bd2c519 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/repo.ts @@ -0,0 +1,4 @@ +export class Repo { + constructor(public name: string) {} + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/user.ts new file mode 100644 index 0000000000..a4f084b289 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-instanceof-narrowing/src/user.ts @@ -0,0 +1,4 @@ +export class User { + constructor(public name: string) {} + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-local-shadow/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-local-shadow/src/app.ts new file mode 100644 index 0000000000..2bffcd3554 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-local-shadow/src/app.ts @@ -0,0 +1,10 @@ +import { save } from './utils'; + +// Local definition shadows the imported one +function save(x: string): void { + console.log('local save:', x); +} + +function run(): void { + save('test'); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-local-shadow/src/utils.ts b/gitnexus/test/fixtures/lang-resolution/typescript-local-shadow/src/utils.ts new file mode 100644 index 0000000000..7b82ed99fa --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-local-shadow/src/utils.ts @@ -0,0 +1,3 @@ +export function save(data: string): void { + console.log('utils save:', data); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/app.ts new file mode 100644 index 0000000000..1599b28320 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/app.ts @@ -0,0 +1,18 @@ +import { User } from './models/User'; +import { Repo } from './models/Repo'; + +class UserService { + processUsers(users: User[]) { + for (const user of this.users) { + user.save(); + } + } +} + +class RepoService { + processRepos(repos: Repo[]) { + for (const repo of this.repos) { + repo.save(); + } + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/models/Repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/models/Repo.ts new file mode 100644 index 0000000000..c97f1ed860 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/models/Repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/models/User.ts new file mode 100644 index 0000000000..265b3f05cd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-member-access-for-loop/src/models/User.ts @@ -0,0 +1,3 @@ +export class User { + save() {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-member-calls/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-member-calls/src/app.ts new file mode 100644 index 0000000000..0babfd37b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-member-calls/src/app.ts @@ -0,0 +1,6 @@ +import { User } from './user'; + +export function processUser(): boolean { + const user = new User(); + return user.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-member-calls/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-member-calls/src/user.ts new file mode 100644 index 0000000000..e2af97ca77 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-member-calls/src/user.ts @@ -0,0 +1,5 @@ +export class User { + save(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/app.ts new file mode 100644 index 0000000000..1205ec8af8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/app.ts @@ -0,0 +1,5 @@ +import { formatData } from './format-upper'; + +export function processInput(): string { + return formatData('hello'); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/format-prefix.ts b/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/format-prefix.ts new file mode 100644 index 0000000000..617cf16dfb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/format-prefix.ts @@ -0,0 +1,3 @@ +export function formatData(data: string, prefix: string): string { + return prefix + data; +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/format-upper.ts b/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/format-upper.ts new file mode 100644 index 0000000000..7f688c57c3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-named-imports/src/format-upper.ts @@ -0,0 +1,3 @@ +export function formatData(data: string): string { + return data.toUpperCase(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/app.ts new file mode 100644 index 0000000000..41e8275a1e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/app.ts @@ -0,0 +1,12 @@ +import { User } from './models/User'; +import { Repo } from './models/Repo'; + +// Both 'user' and 'repo' are created via constructor inference (no type annotation). +// The enclosing scope is 'run@0', with varNames 'user' and 'repo'. +// user.save() must resolve to User#save and repo.save() must resolve to Repo#save. +export function run(): void { + const user = new User(); + const repo = new Repo(); + user.save(); + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/db/Cache.ts b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/db/Cache.ts new file mode 100644 index 0000000000..15aa58789e --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/db/Cache.ts @@ -0,0 +1,3 @@ +export class Cache { + store(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/db/Database.ts b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/db/Database.ts new file mode 100644 index 0000000000..f45b31d9a9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/db/Database.ts @@ -0,0 +1,3 @@ +export class Database { + persist(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/models/Repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/models/Repo.ts new file mode 100644 index 0000000000..19631246b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/models/Repo.ts @@ -0,0 +1,5 @@ +export class Repo { + save(): boolean { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/models/User.ts new file mode 100644 index 0000000000..e2af97ca77 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-overloaded-receiver/models/User.ts @@ -0,0 +1,5 @@ +export class User { + save(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-parent-resolution/src/models/Base.ts b/gitnexus/test/fixtures/lang-resolution/typescript-parent-resolution/src/models/Base.ts new file mode 100644 index 0000000000..5717e68455 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-parent-resolution/src/models/Base.ts @@ -0,0 +1,7 @@ +export class BaseModel { + save(): boolean { return true; } +} + +export interface Serializable { + serialize(): string; +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-parent-resolution/src/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-parent-resolution/src/models/User.ts new file mode 100644 index 0000000000..76d5c63bc8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-parent-resolution/src/models/User.ts @@ -0,0 +1,5 @@ +import { BaseModel, Serializable } from './Base'; + +export class User extends BaseModel implements Serializable { + serialize(): string { return ''; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/app.ts new file mode 100644 index 0000000000..228ddd50fb --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/app.ts @@ -0,0 +1,9 @@ +import { User } from './user'; +import { Repo } from './repo'; + +export function processEntities(): void { + const user: User = new User(); + const repo: Repo = new Repo(); + user.save(); + repo.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/repo.ts new file mode 100644 index 0000000000..19631246b7 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/repo.ts @@ -0,0 +1,5 @@ +export class Repo { + save(): boolean { + return false; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/user.ts new file mode 100644 index 0000000000..e2af97ca77 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-receiver-resolution/src/user.ts @@ -0,0 +1,5 @@ +export class User { + save(): boolean { + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/app.ts new file mode 100644 index 0000000000..d031fe5832 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/app.ts @@ -0,0 +1,9 @@ +import { User, Repo } from './models'; + +function main(): void { + const user = new User(); + user.save(); + + const repo = new Repo(); + repo.persist(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/base.ts b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/base.ts new file mode 100644 index 0000000000..b44acaacfd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/base.ts @@ -0,0 +1,11 @@ +export class User { + save(): void { + console.log('saving user'); + } +} + +export class Repo { + persist(): void { + console.log('persisting repo'); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/models.ts b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/models.ts new file mode 100644 index 0000000000..97eab7bc39 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-chain/src/models.ts @@ -0,0 +1,3 @@ +// Barrel re-export — no local definitions +export { User } from './base'; +export { Repo } from './base'; diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/app.ts new file mode 100644 index 0000000000..2ec38490b9 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/app.ts @@ -0,0 +1,9 @@ +import type { User, Repo } from './models'; + +function main(): void { + const user = new User(); + user.save(); + + const repo = new Repo(); + repo.persist(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/base.ts b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/base.ts new file mode 100644 index 0000000000..b44acaacfd --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/base.ts @@ -0,0 +1,11 @@ +export class User { + save(): void { + console.log('saving user'); + } +} + +export class Repo { + persist(): void { + console.log('persisting repo'); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/models.ts b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/models.ts new file mode 100644 index 0000000000..4bfe62a5da --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-reexport-type/src/models.ts @@ -0,0 +1,3 @@ +// Type-only re-exports +export type { User } from './base'; +export type { Repo } from './base'; diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/app.ts new file mode 100644 index 0000000000..be70c92b74 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/app.ts @@ -0,0 +1,10 @@ +import { User } from './user'; +import { Repo } from './repo'; + +export function handleUser(entity: User): void { + entity.save(); +} + +export function handleRepo(entity: Repo): void { + entity.save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/repo.ts new file mode 100644 index 0000000000..340937eb35 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/user.ts b/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/user.ts new file mode 100644 index 0000000000..a0a791e8e5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-scoped-receiver/src/user.ts @@ -0,0 +1,3 @@ +export class User { + save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-self-this-resolution/src/models/Repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-self-this-resolution/src/models/Repo.ts new file mode 100644 index 0000000000..939092cce3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-self-this-resolution/src/models/Repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save(): boolean { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-self-this-resolution/src/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-self-this-resolution/src/models/User.ts new file mode 100644 index 0000000000..4c8e33f09f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-self-this-resolution/src/models/User.ts @@ -0,0 +1,6 @@ +export class User { + save(): boolean { return true; } + process(): void { + this.save(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/app.ts new file mode 100644 index 0000000000..7beccfd559 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/app.ts @@ -0,0 +1,7 @@ +import { UserService } from './services/UserService'; + +// Chain base is a class name, not a variable. +// Requires class-as-receiver fallback on the chain base resolution. +export function processUser(): void { + UserService.findUser().save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/models/Repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/models/Repo.ts new file mode 100644 index 0000000000..340937eb35 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/models/Repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/models/User.ts new file mode 100644 index 0000000000..a0a791e8e5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/models/User.ts @@ -0,0 +1,3 @@ +export class User { + save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/services/UserService.ts b/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/services/UserService.ts new file mode 100644 index 0000000000..54f12c1398 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-static-chain/services/UserService.ts @@ -0,0 +1,7 @@ +import { User } from '../models/User'; + +export class UserService { + static findUser(): User { + return new User(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/Base.ts b/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/Base.ts new file mode 100644 index 0000000000..4ac02f5965 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/Base.ts @@ -0,0 +1,3 @@ +export class BaseModel { + save(): boolean { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/Repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/Repo.ts new file mode 100644 index 0000000000..939092cce3 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/Repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save(): boolean { return true; } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/User.ts new file mode 100644 index 0000000000..0a2b2bc24a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-super-resolution/src/models/User.ts @@ -0,0 +1,8 @@ +import { BaseModel } from './Base'; + +export class User extends BaseModel { + save(): boolean { + super.save(); + return true; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/app.ts new file mode 100644 index 0000000000..23b1fda90f --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/app.ts @@ -0,0 +1,7 @@ +import { UserService } from './services/UserService'; + +// svc is typed via parameter annotation, NOT constructor binding. +// The chain base type must come from typeEnv, not receiverMap. +export function processUser(svc: UserService): void { + svc.getUser().save(); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/models/Repo.ts b/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/models/Repo.ts new file mode 100644 index 0000000000..340937eb35 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/models/Repo.ts @@ -0,0 +1,3 @@ +export class Repo { + save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/models/User.ts b/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/models/User.ts new file mode 100644 index 0000000000..a0a791e8e5 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/models/User.ts @@ -0,0 +1,3 @@ +export class User { + save(): void {} +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/services/UserService.ts b/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/services/UserService.ts new file mode 100644 index 0000000000..510f536643 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-typed-param-chain/services/UserService.ts @@ -0,0 +1,7 @@ +import { User } from '../models/User'; + +export class UserService { + getUser(): User { + return new User(); + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-variadic-resolution/src/app.ts b/gitnexus/test/fixtures/lang-resolution/typescript-variadic-resolution/src/app.ts new file mode 100644 index 0000000000..dc3fb746f0 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-variadic-resolution/src/app.ts @@ -0,0 +1,5 @@ +import { logEntry } from './logger'; + +export function processInput(): void { + logEntry('hello', 'world', 'test'); +} diff --git a/gitnexus/test/fixtures/lang-resolution/typescript-variadic-resolution/src/logger.ts b/gitnexus/test/fixtures/lang-resolution/typescript-variadic-resolution/src/logger.ts new file mode 100644 index 0000000000..4c8a7a6b71 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/typescript-variadic-resolution/src/logger.ts @@ -0,0 +1,3 @@ +export function logEntry(...messages: string[]): void { + console.log(messages.join(' ')); +} diff --git a/gitnexus/test/fixtures/local-backend-seed.ts b/gitnexus/test/fixtures/local-backend-seed.ts new file mode 100644 index 0000000000..6958fe5b57 --- /dev/null +++ b/gitnexus/test/fixtures/local-backend-seed.ts @@ -0,0 +1,48 @@ +import type { FTSIndexDef } from '../helpers/test-indexed-db.js'; + +export const LOCAL_BACKEND_SEED_DATA = [ + // Files + `CREATE (f:File {id: 'file:auth.ts', name: 'auth.ts', filePath: 'src/auth.ts', content: 'auth module'})`, + `CREATE (f:File {id: 'file:utils.ts', name: 'utils.ts', filePath: 'src/utils.ts', content: 'utils module'})`, + // Functions + `CREATE (fn:Function {id: 'func:login', name: 'login', filePath: 'src/auth.ts', startLine: 1, endLine: 15, isExported: true, content: 'function login() {}', description: 'User login'})`, + `CREATE (fn:Function {id: 'func:validate', name: 'validate', filePath: 'src/auth.ts', startLine: 17, endLine: 25, isExported: true, content: 'function validate() {}', description: 'Validate input'})`, + `CREATE (fn:Function {id: 'func:hash', name: 'hash', filePath: 'src/utils.ts', startLine: 1, endLine: 8, isExported: true, content: 'function hash() {}', description: 'Hash utility'})`, + // Class + `CREATE (c:Class {id: 'class:AuthService', name: 'AuthService', filePath: 'src/auth.ts', startLine: 30, endLine: 60, isExported: true, content: 'class AuthService {}', description: 'Authentication service'})`, + `CREATE (c:Class {id: 'class:BaseService', name: 'BaseService', filePath: 'src/base.ts', startLine: 1, endLine: 20, isExported: true, content: 'class BaseService {}', description: 'Base service class'})`, + // Methods + `CREATE (m:Method {id: 'method:AuthService.authenticate', name: 'authenticate', filePath: 'src/auth.ts', startLine: 35, endLine: 45, isExported: false, content: 'authenticate() {}', description: 'Authenticate user'})`, + `CREATE (m:Method {id: 'method:BaseService.authenticate', name: 'authenticate', filePath: 'src/base.ts', startLine: 5, endLine: 10, isExported: false, content: 'authenticate() {}', description: 'Base authenticate'})`, + // Community + `CREATE (c:Community {id: 'comm:auth', label: 'Auth', heuristicLabel: 'Authentication', keywords: ['auth', 'login'], description: 'Auth module', enrichedBy: 'heuristic', cohesion: 0.8, symbolCount: 3})`, + // Process + `CREATE (p:Process {id: 'proc:login-flow', label: 'LoginFlow', heuristicLabel: 'User Login', processType: 'intra_community', stepCount: 2, communities: ['auth'], entryPointId: 'func:login', terminalId: 'func:validate'})`, + // Relationships + `MATCH (a:Function), (b:Function) WHERE a.id = 'func:login' AND b.id = 'func:validate' + CREATE (a)-[:CodeRelation {type: 'CALLS', confidence: 1.0, reason: 'direct', step: 0}]->(b)`, + `MATCH (a:Function), (b:Function) WHERE a.id = 'func:login' AND b.id = 'func:hash' + CREATE (a)-[:CodeRelation {type: 'CALLS', confidence: 0.9, reason: 'import-resolved', step: 0}]->(b)`, + `MATCH (a:Function), (c:Community) WHERE a.id = 'func:login' AND c.id = 'comm:auth' + CREATE (a)-[:CodeRelation {type: 'MEMBER_OF', confidence: 1.0, reason: '', step: 0}]->(c)`, + `MATCH (a:Function), (p:Process) WHERE a.id = 'func:login' AND p.id = 'proc:login-flow' + CREATE (a)-[:CodeRelation {type: 'STEP_IN_PROCESS', confidence: 1.0, reason: '', step: 1}]->(p)`, + `MATCH (a:Function), (p:Process) WHERE a.id = 'func:validate' AND p.id = 'proc:login-flow' + CREATE (a)-[:CodeRelation {type: 'STEP_IN_PROCESS', confidence: 1.0, reason: '', step: 2}]->(p)`, + // HAS_METHOD: AuthService -> authenticate + `MATCH (c:Class), (m:Method) WHERE c.id = 'class:AuthService' AND m.id = 'method:AuthService.authenticate' + CREATE (c)-[:CodeRelation {type: 'HAS_METHOD', confidence: 1.0, reason: 'class-method', step: 0}]->(m)`, + // OVERRIDES: AuthService.authenticate -> BaseService.authenticate + `MATCH (a:Method), (b:Method) WHERE a.id = 'method:AuthService.authenticate' AND b.id = 'method:BaseService.authenticate' + CREATE (a)-[:CodeRelation {type: 'OVERRIDES', confidence: 1.0, reason: 'mro-resolution', step: 0}]->(b)`, + // HAS_METHOD: BaseService -> authenticate + `MATCH (c:Class), (m:Method) WHERE c.id = 'class:BaseService' AND m.id = 'method:BaseService.authenticate' + CREATE (c)-[:CodeRelation {type: 'HAS_METHOD', confidence: 1.0, reason: 'class-method', step: 0}]->(m)`, +]; + +export const LOCAL_BACKEND_FTS_INDEXES: FTSIndexDef[] = [ + { table: 'Function', indexName: 'function_fts', columns: ['name', 'content', 'description'] }, + { table: 'Class', indexName: 'class_fts', columns: ['name', 'content', 'description'] }, + { table: 'Method', indexName: 'method_fts', columns: ['name', 'content', 'description'] }, + { table: 'File', indexName: 'file_fts', columns: ['name', 'content'] }, +]; diff --git a/gitnexus/test/fixtures/mini-repo/src/db.ts b/gitnexus/test/fixtures/mini-repo/src/db.ts new file mode 100644 index 0000000000..90a845304c --- /dev/null +++ b/gitnexus/test/fixtures/mini-repo/src/db.ts @@ -0,0 +1,19 @@ +import type { ValidationResult } from './validator'; + +export interface DbRecord { + id: string; + value: string; + timestamp: number; +} + +export async function saveToDb(input: ValidationResult): Promise<DbRecord> { + return { + id: Math.random().toString(36), + value: input.value, + timestamp: Date.now(), + }; +} + +export async function findById(id: string): Promise<DbRecord | null> { + return null; +} diff --git a/gitnexus/test/fixtures/mini-repo/src/formatter.ts b/gitnexus/test/fixtures/mini-repo/src/formatter.ts new file mode 100644 index 0000000000..09137614e5 --- /dev/null +++ b/gitnexus/test/fixtures/mini-repo/src/formatter.ts @@ -0,0 +1,15 @@ +import type { DbRecord } from './db'; + +export function formatResponse(record: DbRecord): string { + return JSON.stringify({ + success: true, + data: record, + }); +} + +export function formatError(message: string): string { + return JSON.stringify({ + success: false, + error: message, + }); +} diff --git a/gitnexus/test/fixtures/mini-repo/src/handler.ts b/gitnexus/test/fixtures/mini-repo/src/handler.ts new file mode 100644 index 0000000000..3a988cb661 --- /dev/null +++ b/gitnexus/test/fixtures/mini-repo/src/handler.ts @@ -0,0 +1,15 @@ +import { validateInput } from './validator'; +import { saveToDb } from './db'; +import { formatResponse } from './formatter'; + +export class RequestHandler { + async handleRequest(input: string): Promise<string> { + const validated = validateInput(input); + const saved = await saveToDb(validated); + return formatResponse(saved); + } +} + +export function createHandler(): RequestHandler { + return new RequestHandler(); +} diff --git a/gitnexus/test/fixtures/mini-repo/src/index.ts b/gitnexus/test/fixtures/mini-repo/src/index.ts new file mode 100644 index 0000000000..1eb88011ff --- /dev/null +++ b/gitnexus/test/fixtures/mini-repo/src/index.ts @@ -0,0 +1,5 @@ +export { RequestHandler, createHandler } from './handler'; +export { validateInput, sanitize } from './validator'; +export { formatResponse, formatError } from './formatter'; +export { processRequest, errorMiddleware } from './middleware'; +export { createLogEntry, formatLogEntry, logMessage } from './logger'; diff --git a/gitnexus/test/fixtures/mini-repo/src/logger.ts b/gitnexus/test/fixtures/mini-repo/src/logger.ts new file mode 100644 index 0000000000..6e9ac1438d --- /dev/null +++ b/gitnexus/test/fixtures/mini-repo/src/logger.ts @@ -0,0 +1,18 @@ +export interface LogEntry { + level: string; + message: string; + timestamp: number; +} + +export function createLogEntry(level: string, message: string): LogEntry { + return { level, message, timestamp: Date.now() }; +} + +export function formatLogEntry(entry: LogEntry): string { + return `[${entry.level}] ${entry.message}`; +} + +export function logMessage(level: string, message: string): string { + const entry = createLogEntry(level, message); + return formatLogEntry(entry); +} diff --git a/gitnexus/test/fixtures/mini-repo/src/middleware.ts b/gitnexus/test/fixtures/mini-repo/src/middleware.ts new file mode 100644 index 0000000000..3870ed490b --- /dev/null +++ b/gitnexus/test/fixtures/mini-repo/src/middleware.ts @@ -0,0 +1,11 @@ +import { sanitize } from './validator'; +import { logMessage } from './logger'; + +export function processRequest(input: string): string { + const clean = sanitize(input); + return logMessage('info', `Processing: ${clean}`); +} + +export function errorMiddleware(error: string): string { + return logMessage('error', error); +} diff --git a/gitnexus/test/fixtures/mini-repo/src/validator.ts b/gitnexus/test/fixtures/mini-repo/src/validator.ts new file mode 100644 index 0000000000..0742d26a1e --- /dev/null +++ b/gitnexus/test/fixtures/mini-repo/src/validator.ts @@ -0,0 +1,15 @@ +export interface ValidationResult { + valid: boolean; + value: string; +} + +export function validateInput(input: string): ValidationResult { + if (!input || input.trim().length === 0) { + return { valid: false, value: '' }; + } + return { valid: true, value: input.trim() }; +} + +export function sanitize(input: string): string { + return input.replace(/[<>]/g, ''); +} diff --git a/gitnexus/test/fixtures/sample-code/simple.c b/gitnexus/test/fixtures/sample-code/simple.c new file mode 100644 index 0000000000..9da0cfccca --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.c @@ -0,0 +1,13 @@ +#include <stdio.h> + +int add(int a, int b) { + return a + b; +} + +static int internal_helper(void) { + return 0; +} + +void print_message(const char* msg) { + printf("%s\n", msg); +} diff --git a/gitnexus/test/fixtures/sample-code/simple.cpp b/gitnexus/test/fixtures/sample-code/simple.cpp new file mode 100644 index 0000000000..f63b4e4e53 --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.cpp @@ -0,0 +1,19 @@ +#include <string> + +class UserManager { +public: + void addUser(const std::string& name) { + users_.push_back(name); + } + + int getCount() const { + return static_cast<int>(users_.size()); + } + +private: + std::vector<std::string> users_; +}; + +int helperFunction(int x) { + return x * 2; +} diff --git a/gitnexus/test/fixtures/sample-code/simple.cs b/gitnexus/test/fixtures/sample-code/simple.cs new file mode 100644 index 0000000000..cfb2b971e8 --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.cs @@ -0,0 +1,55 @@ +using System; +using System.Collections.Generic; + +namespace SampleApp +{ + public interface ICalculator + { + int Add(int a, int b); + } + + public class Calculator : ICalculator + { + public int Result { get; private set; } + + public Calculator() { Result = 0; } + + public int Add(int a, int b) + { + Result = a + b; + LogResult(Result); + return Result; + } + + private void LogResult(int value) + { + Console.WriteLine(value); + } + + private int Multiply(int a, int b) { return a * b; } + } + + internal class Helper + { + public void DoWork() + { + var calc = new Calculator(); + calc.Add(1, 2); + } + } + + public enum Operation + { + Add, + Subtract, + Multiply + } + + public record CalculationResult(int Value, Operation Op); + + public struct Point + { + public int X { get; set; } + public int Y { get; set; } + } +} diff --git a/gitnexus/test/fixtures/sample-code/simple.go b/gitnexus/test/fixtures/sample-code/simple.go new file mode 100644 index 0000000000..d0d2f63e03 --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.go @@ -0,0 +1,21 @@ +package main + +import "fmt" + +// ExportedFunction is a public function +func ExportedFunction(name string) string { + return fmt.Sprintf("Hello, %s", name) +} + +// unexportedFunction is a private function +func unexportedFunction() int { + return 42 +} + +type UserService struct { + Name string +} + +func (s *UserService) GetName() string { + return s.Name +} diff --git a/gitnexus/test/fixtures/sample-code/simple.java b/gitnexus/test/fixtures/sample-code/simple.java new file mode 100644 index 0000000000..ed5572dd8a --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.java @@ -0,0 +1,15 @@ +public class UserService { + private String name; + + public UserService(String name) { + this.name = name; + } + + public String getName() { + return this.name; + } + + private void reset() { + this.name = ""; + } +} diff --git a/gitnexus/test/fixtures/sample-code/simple.js b/gitnexus/test/fixtures/sample-code/simple.js new file mode 100644 index 0000000000..c9ad42470f --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.js @@ -0,0 +1,32 @@ +const path = require('path'); + +class EventEmitter { + constructor() { + this.listeners = {}; + } + + on(event, callback) { + if (!this.listeners[event]) { + this.listeners[event] = []; + } + this.listeners[event].push(callback); + } + + emit(event, ...args) { + const handlers = this.listeners[event] || []; + handlers.forEach(handler => handler(...args)); + } +} + +function createLogger(prefix) { + return { + log: (msg) => console.log(`[${prefix}] ${msg}`), + error: (msg) => console.error(`[${prefix}] ${msg}`), + }; +} + +const formatDate = (date) => { + return date.toISOString().split('T')[0]; +}; + +module.exports = { EventEmitter, createLogger, formatDate }; diff --git a/gitnexus/test/fixtures/sample-code/simple.php b/gitnexus/test/fixtures/sample-code/simple.php new file mode 100644 index 0000000000..c28b38ec1d --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.php @@ -0,0 +1,21 @@ +<?php + +function topLevelFunction(string $name): string { + return "Hello, " . $name; +} + +class UserRepository { + private array $users = []; + + public function addUser(string $name): void { + $this->users[] = $name; + } + + private function validateName(string $name): bool { + return strlen($name) > 0; + } + + public function getUsers(): array { + return $this->users; + } +} diff --git a/gitnexus/test/fixtures/sample-code/simple.py b/gitnexus/test/fixtures/sample-code/simple.py new file mode 100644 index 0000000000..b7798b1aba --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.py @@ -0,0 +1,14 @@ +def public_function(x: int, y: int) -> int: + """A public function.""" + return x + y + +def _private_helper(data: str) -> str: + """A private helper function.""" + return data.strip() + +class Calculator: + def add(self, a: int, b: int) -> int: + return a + b + + def _reset(self) -> None: + pass diff --git a/gitnexus/test/fixtures/sample-code/simple.rs b/gitnexus/test/fixtures/sample-code/simple.rs new file mode 100644 index 0000000000..ccd4c6a175 --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.rs @@ -0,0 +1,17 @@ +pub fn public_function(x: i32) -> i32 { + x + 1 +} + +fn private_function() -> &'static str { + "private" +} + +pub struct Config { + pub name: String, +} + +impl Config { + pub fn new(name: &str) -> Self { + Config { name: name.to_string() } + } +} diff --git a/gitnexus/test/fixtures/sample-code/simple.swift b/gitnexus/test/fixtures/sample-code/simple.swift new file mode 100644 index 0000000000..f67066e8a1 --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.swift @@ -0,0 +1,19 @@ +class UserManager { + var users: [String] = [] + + init() { + users = [] + } + + func addUser(_ name: String) { + users.append(name) + } + + public func getCount() -> Int { + return users.count + } +} + +func helperFunction() -> String { + return "swift helper" +} diff --git a/gitnexus/test/fixtures/sample-code/simple.ts b/gitnexus/test/fixtures/sample-code/simple.ts new file mode 100644 index 0000000000..f7d5e6d4d9 --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.ts @@ -0,0 +1,27 @@ +export interface UserConfig { + name: string; + email: string; + active: boolean; +} + +export function validateUser(config: UserConfig): boolean { + return config.name.length > 0 && config.email.includes('@'); +} + +export class UserService { + private users: UserConfig[] = []; + + addUser(user: UserConfig): void { + if (validateUser(user)) { + this.users.push(user); + } + } + + getUser(name: string): UserConfig | undefined { + return this.users.find(u => u.name === name); + } +} + +function internalHelper(): string { + return 'helper'; +} diff --git a/gitnexus/test/fixtures/sample-code/simple.tsx b/gitnexus/test/fixtures/sample-code/simple.tsx new file mode 100644 index 0000000000..698c57e67c --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/simple.tsx @@ -0,0 +1,41 @@ +import React, { useState } from 'react'; + +interface ButtonProps { + label: string; + onClick: () => void; +} + +export class Counter extends React.Component<{}, { count: number }> { + state = { count: 0 }; + + increment() { + this.setState({ count: this.state.count + 1 }); + } + + render() { + return <button onClick={() => this.increment()}>{this.state.count}</button>; + } +} + +export const Button: React.FC<ButtonProps> = ({ label, onClick }) => { + return <button onClick={onClick}>{label}</button>; +}; + +export function useCounter(initial: number = 0) { + const [count, setCount] = useState(initial); + const increment = () => setCount(c => c + 1); + const decrement = () => setCount(c => c - 1); + return { count, increment, decrement }; +} + +const App = () => { + const { count, increment } = useCounter(); + return ( + <div> + <h1>Count: {count}</h1> + <Button label="+" onClick={increment} /> + </div> + ); +}; + +export default App; diff --git a/gitnexus/test/fixtures/sample-code/swift-extension.swift b/gitnexus/test/fixtures/sample-code/swift-extension.swift new file mode 100644 index 0000000000..7f7089f699 --- /dev/null +++ b/gitnexus/test/fixtures/sample-code/swift-extension.swift @@ -0,0 +1,16 @@ +protocol Greetable { + func greet() -> String +} + +class Person { + var name: String + init(name: String) { + self.name = name + } +} + +extension Person: Greetable { + func greet() -> String { + return "Hello, \(name)" + } +} diff --git a/gitnexus/test/fixtures/search-seed.ts b/gitnexus/test/fixtures/search-seed.ts new file mode 100644 index 0000000000..14d2c32ce1 --- /dev/null +++ b/gitnexus/test/fixtures/search-seed.ts @@ -0,0 +1,31 @@ +import type { FTSIndexDef } from '../helpers/test-indexed-db.js'; + +export const SEARCH_SEED_DATA = [ + // File nodes — content is the searchable field + `CREATE (n:File {id: 'file:auth.ts', name: 'auth.ts', filePath: 'src/auth.ts', content: 'authentication module for user login and session management'})`, + `CREATE (n:File {id: 'file:router.ts', name: 'router.ts', filePath: 'src/router.ts', content: 'HTTP request routing and middleware pipeline'})`, + `CREATE (n:File {id: 'file:utils.ts', name: 'utils.ts', filePath: 'src/utils.ts', content: 'general utility functions for string manipulation'})`, + + // Function nodes + `CREATE (n:Function {id: 'func:validateUser', name: 'validateUser', filePath: 'src/auth.ts', startLine: 10, endLine: 30, isExported: true, content: 'validates user credentials and authentication tokens', description: 'user auth validator'})`, + `CREATE (n:Function {id: 'func:hashPassword', name: 'hashPassword', filePath: 'src/auth.ts', startLine: 35, endLine: 50, isExported: true, content: 'hashes user password with bcrypt for secure authentication', description: 'password hashing'})`, + `CREATE (n:Function {id: 'func:handleRoute', name: 'handleRoute', filePath: 'src/router.ts', startLine: 1, endLine: 20, isExported: true, content: 'handles HTTP request routing to controllers', description: 'route handler'})`, + `CREATE (n:Function {id: 'func:formatString', name: 'formatString', filePath: 'src/utils.ts', startLine: 1, endLine: 10, isExported: true, content: 'formats a string with template placeholders', description: 'string formatter'})`, + + // Class nodes + `CREATE (n:Class {id: 'class:AuthService', name: 'AuthService', filePath: 'src/auth.ts', startLine: 55, endLine: 120, isExported: true, content: 'authentication service handling user login logout and token refresh', description: 'auth service class'})`, + + // Method nodes + `CREATE (n:Method {id: 'method:AuthService.login', name: 'login', filePath: 'src/auth.ts', startLine: 60, endLine: 80, isExported: false, content: 'authenticates user with username and password returning JWT token', description: 'login method'})`, + + // Interface nodes + `CREATE (n:Interface {id: 'iface:UserCredentials', name: 'UserCredentials', filePath: 'src/auth.ts', startLine: 1, endLine: 8, isExported: true, content: 'interface for user authentication credentials username password', description: 'credentials interface'})`, +]; + +export const SEARCH_FTS_INDEXES: FTSIndexDef[] = [ + { table: 'File', indexName: 'file_fts', columns: ['name', 'content'] }, + { table: 'Function', indexName: 'function_fts', columns: ['name', 'content', 'description'] }, + { table: 'Class', indexName: 'class_fts', columns: ['name', 'content', 'description'] }, + { table: 'Method', indexName: 'method_fts', columns: ['name', 'content', 'description'] }, + { table: 'Interface', indexName: 'interface_fts', columns: ['name', 'content', 'description'] }, +]; diff --git a/gitnexus/test/global-setup.ts b/gitnexus/test/global-setup.ts new file mode 100644 index 0000000000..f5760a1b19 --- /dev/null +++ b/gitnexus/test/global-setup.ts @@ -0,0 +1,54 @@ +/** + * Vitest globalSetup — runs once in the MAIN process before any forks. + * + * Creates a single shared LadybugDB with full schema so that forked test + * files only need to clear + reseed data instead of recreating the + * entire schema each time (~29 DDL queries per file eliminated). + * + * The dbPath is shared with test files via vitest's provide/inject API. + */ +import path from 'path'; +import lbug from '@ladybugdb/core'; +import type { GlobalSetupContext } from 'vitest/node'; +import { createTempDir } from './helpers/test-db.js'; +import { + NODE_SCHEMA_QUERIES, + REL_SCHEMA_QUERIES, + EMBEDDING_SCHEMA, +} from '../src/core/lbug/schema.js'; + +export default async function setup({ provide }: GlobalSetupContext) { + const tmpHandle = await createTempDir('gitnexus-shared-'); + const dbPath = path.join(tmpHandle.dbPath, 'lbug'); + + // Create DB with full schema + const db = new lbug.Database(dbPath); + const conn = new lbug.Connection(db); + + for (const q of NODE_SCHEMA_QUERIES) { + await conn.query(q); + } + for (const q of REL_SCHEMA_QUERIES) { + await conn.query(q); + } + await conn.query(EMBEDDING_SCHEMA); + + // Pre-install FTS extension so forks don't need to download it + try { + await conn.query('INSTALL fts'); + await conn.query('LOAD EXTENSION fts'); + } catch { + // FTS may already be installed system-wide — not fatal + } + + await conn.close(); + await db.close(); + + // Share the dbPath with all test files via inject('lbugDbPath') + provide('lbugDbPath', dbPath); + + // Teardown: remove temp directory after all tests complete + return async () => { + await tmpHandle.cleanup(); + }; +} diff --git a/gitnexus/test/helpers/test-db.ts b/gitnexus/test/helpers/test-db.ts new file mode 100644 index 0000000000..c700ac0770 --- /dev/null +++ b/gitnexus/test/helpers/test-db.ts @@ -0,0 +1,32 @@ +/** + * Test helper: Temporary LadybugDB factory + * + * Creates a temp directory, initializes LadybugDB with schema, and + * optionally loads minimal test data. Returns a cleanup function. + */ +import fs from 'fs/promises'; +import os from 'os'; +import path from 'path'; + +export interface TestDBHandle { + dbPath: string; + cleanup: () => Promise<void>; +} + +/** + * Create a temporary directory for LadybugDB tests. + * Returns the path and a cleanup function. + */ +export async function createTempDir(prefix: string = 'gitnexus-test-'): Promise<TestDBHandle> { + const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), prefix)); + return { + dbPath: tmpDir, + cleanup: async () => { + try { + await fs.rm(tmpDir, { recursive: true, force: true }); + } catch { + // best-effort cleanup + } + }, + }; +} diff --git a/gitnexus/test/helpers/test-graph.ts b/gitnexus/test/helpers/test-graph.ts new file mode 100644 index 0000000000..40c598e12e --- /dev/null +++ b/gitnexus/test/helpers/test-graph.ts @@ -0,0 +1,90 @@ +/** + * Test helper: In-memory knowledge graph builder + * + * Provides a convenient API for constructing test graphs + * without touching the filesystem or LadybugDB. + */ +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import type { KnowledgeGraph, GraphNode, NodeLabel, RelationshipType } from '../../src/core/graph/types.js'; + +export interface TestNodeInput { + id: string; + label: NodeLabel; + name: string; + filePath: string; + startLine?: number; + endLine?: number; + isExported?: boolean; + extra?: Record<string, any>; +} + +export interface TestRelInput { + sourceId: string; + targetId: string; + type: RelationshipType; + confidence?: number; + reason?: string; + step?: number; +} + +/** + * Build a test graph from simple input arrays. + */ +export function buildTestGraph( + nodes: TestNodeInput[], + relationships: TestRelInput[] = [], +): KnowledgeGraph { + const graph = createKnowledgeGraph(); + + for (const n of nodes) { + graph.addNode({ + id: n.id, + label: n.label, + properties: { + name: n.name, + filePath: n.filePath, + startLine: n.startLine, + endLine: n.endLine, + isExported: n.isExported, + ...n.extra, + }, + }); + } + + for (const r of relationships) { + graph.addRelationship({ + id: `${r.sourceId}-${r.type}-${r.targetId}`, + sourceId: r.sourceId, + targetId: r.targetId, + type: r.type, + confidence: r.confidence ?? 1.0, + reason: r.reason ?? '', + step: r.step, + }); + } + + return graph; +} + +/** + * Create a minimal graph with a few files, functions, and relationships. + * Useful as a baseline for integration tests. + */ +export function createMinimalTestGraph(): KnowledgeGraph { + return buildTestGraph( + [ + { id: 'File:src/index.ts', label: 'File', name: 'index.ts', filePath: 'src/index.ts' }, + { id: 'File:src/utils.ts', label: 'File', name: 'utils.ts', filePath: 'src/utils.ts' }, + { id: 'Function:src/index.ts:main:1', label: 'Function', name: 'main', filePath: 'src/index.ts', startLine: 1, endLine: 10, isExported: true }, + { id: 'Function:src/utils.ts:helper:1', label: 'Function', name: 'helper', filePath: 'src/utils.ts', startLine: 1, endLine: 5, isExported: true }, + { id: 'Class:src/index.ts:App:12', label: 'Class', name: 'App', filePath: 'src/index.ts', startLine: 12, endLine: 30, isExported: true }, + { id: 'Folder:src', label: 'Folder', name: 'src', filePath: 'src' }, + ], + [ + { sourceId: 'Function:src/index.ts:main:1', targetId: 'Function:src/utils.ts:helper:1', type: 'CALLS' }, + { sourceId: 'Function:src/index.ts:main:1', targetId: 'Class:src/index.ts:App:12', type: 'CALLS' }, + { sourceId: 'File:src/index.ts', targetId: 'Function:src/index.ts:main:1', type: 'CONTAINS' }, + { sourceId: 'File:src/utils.ts', targetId: 'Function:src/utils.ts:helper:1', type: 'CONTAINS' }, + ], + ); +} diff --git a/gitnexus/test/helpers/test-indexed-db.ts b/gitnexus/test/helpers/test-indexed-db.ts new file mode 100644 index 0000000000..5f1aa32e35 --- /dev/null +++ b/gitnexus/test/helpers/test-indexed-db.ts @@ -0,0 +1,168 @@ +/** + * Test helper: Indexed LadybugDB lifecycle manager + * + * Uses a shared LadybugDB created by globalSetup (test/global-setup.ts). + * Each test file clears all data, reseeds, and initializes adapters — + * avoiding per-file schema creation overhead. + * + * Cleanup properly closes adapters and releases native resources. + * + * Each test file gets a unique repoId to prevent MCP pool map collisions. + * Seed data is NOT included — each test provides its own via options.seed. + */ +/// <reference path="../vitest.d.ts" /> +import path from 'path'; +import { describe, beforeAll, afterAll, inject } from 'vitest'; +import type { TestDBHandle } from './test-db.js'; +import { + NODE_TABLES, + EMBEDDING_TABLE_NAME, +} from '../../src/core/lbug/schema.js'; + +export interface IndexedDBHandle { + /** Path to the LadybugDB database file */ + dbPath: string; + /** Unique repoId for MCP pool adapter — prevents cross-file collisions */ + repoId: string; + /** Temp directory handle for filesystem cleanup */ + tmpHandle: TestDBHandle; + /** Cleanup: closes adapters and releases native resources */ + cleanup: () => Promise<void>; +} + +let repoCounter = 0; + +/** FTS index definition for withTestLbugDB */ +export interface FTSIndexDef { + table: string; + indexName: string; + columns: string[]; +} + +/** + * Options for withTestLbugDB lifecycle. + * + * Lifecycle: initLbug → loadFTS → dropFTS → clearData → seed + * → createFTS → [closeCoreLbug + poolInitLbug] → afterSetup + */ +export interface WithTestLbugDBOptions { + /** Cypher CREATE queries to insert seed data (runs before core adapter opens). */ + seed?: string[]; + /** FTS indexes to create after seeding. */ + ftsIndexes?: FTSIndexDef[]; + /** Close core adapter and open pool adapter (read-only) after FTS setup. */ + poolAdapter?: boolean; + /** Run after all lifecycle phases complete (mocks, dynamic imports, etc). */ + afterSetup?: (handle: IndexedDBHandle) => Promise<void>; + /** Timeout for beforeAll in ms (default: 30000). */ + timeout?: number; +} + +/** + * Manages the full LadybugDB test lifecycle using the shared global DB: + * data clearing, reseeding, FTS indexes, adapter init/teardown. + * + * All data operations go through the core adapter's writable connection — + * no raw lbug.Database() connections are opened. This avoids file-lock + * conflicts with orphaned native objects from previous test files. + * + * Each call is wrapped in its own `describe` block to isolate lifecycle + * hooks — safe to call multiple times in the same file. + */ +export function withTestLbugDB( + prefix: string, + fn: (handle: IndexedDBHandle) => void, + options?: WithTestLbugDBOptions, +): void { + const ref: { handle: IndexedDBHandle | undefined } = { handle: undefined }; + const timeout = options?.timeout ?? 30000; + + const setup = async () => { + // Get shared DB path from globalSetup (created once with full schema) + const dbPath = inject<'lbugDbPath'>('lbugDbPath'); + const repoId = `test-${prefix}-${Date.now()}-${repoCounter++}`; + + const adapter = await import('../../src/core/lbug/lbug-adapter.js'); + + // 1. Init core adapter (writable) — reuses existing connection if + // already open for this dbPath (no new native objects created). + await adapter.initLbug(dbPath); + + // 2. Load FTS extension (idempotent — skips if already loaded) + await adapter.loadFTSExtension(); + + // 3. Drop stale FTS indexes from previous test file + if (options?.ftsIndexes?.length) { + for (const idx of options.ftsIndexes) { + try { await adapter.dropFTSIndex(idx.table, idx.indexName); } catch { /* may not exist */ } + } + } + + // 4. Clear all data via adapter (DETACH DELETE cascades to relationships) + for (const table of NODE_TABLES) { + await adapter.executeQuery(`MATCH (n:\`${table}\`) DETACH DELETE n`); + } + await adapter.executeQuery(`MATCH (n:${EMBEDDING_TABLE_NAME}) DELETE n`); + + // 5. Seed new data via adapter + if (options?.seed?.length) { + for (const q of options.seed) { + await adapter.executeQuery(q); + } + } + + // 6. Create FTS indexes on fresh data + if (options?.ftsIndexes?.length) { + for (const idx of options.ftsIndexes) { + await adapter.createFTSIndex(idx.table, idx.indexName, idx.columns); + } + } + + // 7. Open pool adapter by injecting the core adapter's writable Database. + // LadybugDB enforces file locks — writable + read-only can't coexist + // on the same path, and db.close() segfaults on macOS due to N-API + // destructor issues. Reusing the writable Database avoids both problems. + // Write protection is enforced at the query validation layer (isWriteQuery) + // rather than at the native DB level. + if (options?.poolAdapter) { + const coreDb = adapter.getDatabase(); + if (!coreDb) throw new Error('withTestLbugDB: core adapter has no open Database'); + const { initLbugWithDb } = await import('../../src/mcp/core/lbug-adapter.js'); + await initLbugWithDb(repoId, coreDb, dbPath); + } + + const cleanup = async () => { + if (options?.poolAdapter) { + const poolAdapter = await import('../../src/mcp/core/lbug-adapter.js'); + await poolAdapter.closeLbug(repoId); + } + await adapter.closeLbug(); + }; + + // tmpHandle.dbPath → parent temp dir (not the lbug file) so tests + // that create sibling directories (e.g. 'storage') still work. + const tmpDir = path.dirname(dbPath); + const tmpHandle: TestDBHandle = { dbPath: tmpDir, cleanup: async () => {} }; + ref.handle = { dbPath, repoId, tmpHandle, cleanup }; + + // 8. User's final setup (mocks, dynamic imports, etc.) + if (options?.afterSetup) { + await options.afterSetup(ref.handle); + } + }; + + const lazyHandle = new Proxy({} as IndexedDBHandle, { + get(_target, prop) { + if (!ref.handle) throw new Error('withTestLbugDB: handle not initialized — beforeAll has not run yet'); + return (ref.handle as any)[prop]; + }, + }); + + // Wrap in describe to scope beforeAll/afterAll — prevents lifecycle + // collisions when multiple withTestLbugDB calls share the same file. + describe(`withTestLbugDB(${prefix})`, () => { + beforeAll(setup, timeout); + afterAll(async () => { if (ref.handle) await ref.handle.cleanup(); }); + fn(lazyHandle); + }); +} diff --git a/gitnexus/test/integration/augmentation.test.ts b/gitnexus/test/integration/augmentation.test.ts new file mode 100644 index 0000000000..339cb33927 --- /dev/null +++ b/gitnexus/test/integration/augmentation.test.ts @@ -0,0 +1,129 @@ +/** + * Integration Tests: Augmentation Engine + * + * augment() against a real indexed LadybugDB + * - Matching pattern returns non-empty string with callers/callees + * - Non-matching pattern returns empty string + * - Pattern shorter than 3 chars returns empty string + */ +import { describe, it, expect, vi } from 'vitest'; +import { withTestLbugDB } from '../helpers/test-indexed-db.js'; + +// ─── Seed data & FTS indexes for augmentation ──────── + +const AUGMENT_SEED_DATA = [ + // File nodes + `CREATE (n:File {id: 'file:auth.ts', name: 'auth.ts', filePath: 'src/auth.ts', content: 'authentication module for user login'})`, + `CREATE (n:File {id: 'file:utils.ts', name: 'utils.ts', filePath: 'src/utils.ts', content: 'utility functions for hashing'})`, + + // Function nodes + `CREATE (n:Function {id: 'func:login', name: 'login', filePath: 'src/auth.ts', startLine: 1, endLine: 15, isExported: true, content: 'function login authenticates user credentials', description: 'user login'})`, + `CREATE (n:Function {id: 'func:validate', name: 'validate', filePath: 'src/auth.ts', startLine: 17, endLine: 25, isExported: true, content: 'function validate checks user input', description: 'input validation'})`, + `CREATE (n:Function {id: 'func:hash', name: 'hash', filePath: 'src/utils.ts', startLine: 1, endLine: 8, isExported: true, content: 'function hash computes bcrypt hash', description: 'password hashing'})`, + + // Class / Method / Interface nodes + `CREATE (n:Class {id: 'class:AuthService', name: 'AuthService', filePath: 'src/auth.ts', startLine: 30, endLine: 60, isExported: true, content: 'class AuthService handles authentication', description: 'auth service'})`, + `CREATE (n:Method {id: 'method:AuthService.login', name: 'loginMethod', filePath: 'src/auth.ts', startLine: 35, endLine: 50, isExported: false, content: 'method login in AuthService', description: 'login method'})`, + `CREATE (n:Interface {id: 'iface:Creds', name: 'Credentials', filePath: 'src/auth.ts', startLine: 1, endLine: 5, isExported: true, content: 'interface Credentials for login authentication', description: 'credentials type'})`, + + // Community & Process nodes + `CREATE (n:Community {id: 'comm:auth', label: 'Auth', heuristicLabel: 'Authentication', keywords: ['auth'], description: 'Auth cluster', enrichedBy: 'heuristic', cohesion: 0.8, symbolCount: 3})`, + `CREATE (n:Process {id: 'proc:login-flow', label: 'LoginFlow', heuristicLabel: 'User Login', processType: 'intra_community', stepCount: 2, communities: ['auth'], entryPointId: 'func:login', terminalId: 'func:validate'})`, + + // Relationships + `MATCH (a:Function), (b:Function) WHERE a.id = 'func:login' AND b.id = 'func:validate' + CREATE (a)-[:CodeRelation {type: 'CALLS', confidence: 1.0, reason: 'direct', step: 0}]->(b)`, + `MATCH (a:Function), (b:Function) WHERE a.id = 'func:login' AND b.id = 'func:hash' + CREATE (a)-[:CodeRelation {type: 'CALLS', confidence: 0.9, reason: 'import-resolved', step: 0}]->(b)`, + `MATCH (a:Function), (c:Community) WHERE a.id = 'func:login' AND c.id = 'comm:auth' + CREATE (a)-[:CodeRelation {type: 'MEMBER_OF', confidence: 1.0, reason: '', step: 0}]->(c)`, + `MATCH (a:Function), (p:Process) WHERE a.id = 'func:login' AND p.id = 'proc:login-flow' + CREATE (a)-[:CodeRelation {type: 'STEP_IN_PROCESS', confidence: 1.0, reason: '', step: 1}]->(p)`, + `MATCH (a:Function), (p:Process) WHERE a.id = 'func:validate' AND p.id = 'proc:login-flow' + CREATE (a)-[:CodeRelation {type: 'STEP_IN_PROCESS', confidence: 1.0, reason: '', step: 2}]->(p)`, +]; + +const AUGMENT_FTS_INDEXES = [ + { table: 'File', indexName: 'file_fts', columns: ['name', 'content'] }, + { table: 'Function', indexName: 'function_fts', columns: ['name', 'content', 'description'] }, + { table: 'Class', indexName: 'class_fts', columns: ['name', 'content', 'description'] }, + { table: 'Method', indexName: 'method_fts', columns: ['name', 'content', 'description'] }, + { table: 'Interface', indexName: 'interface_fts', columns: ['name', 'content', 'description'] }, +]; + +// Mock repo-manager so augment() finds our test DB +vi.mock('../../src/storage/repo-manager.js', () => ({ + listRegisteredRepos: vi.fn(), +})); + +let augment: (pattern: string, cwd?: string) => Promise<string>; + +withTestLbugDB('augment', (handle) => { + describe('augment()', () => { + it('returns non-empty string with relationship info for a matching pattern', async () => { + const result = await augment('login', handle.dbPath); + + expect(result.length).toBeGreaterThan(0); + expect(result).toContain('[GitNexus]'); + expect(result).toContain('login'); + }); + + it('returns empty string for a non-matching pattern', async () => { + const result = await augment('nonexistent_xyz', handle.dbPath); + expect(result).toBe(''); + }); + + it('returns empty string for patterns shorter than 3 characters', async () => { + const result = await augment('ab', handle.dbPath); + expect(result).toBe(''); + }); + + it('returns empty string for empty pattern', async () => { + const result = await augment('', handle.dbPath); + expect(result).toBe(''); + }); + + // ─── Unhappy paths ──────────────────────────────────────────────── + + it('returns empty string for whitespace-only pattern', async () => { + const result = await augment(' ', handle.dbPath); + expect(result).toBe(''); + }); + + it('handles special regex characters in pattern without throwing', async () => { + const result = await augment('func()', handle.dbPath); + expect(typeof result).toBe('string'); + }); + + it('handles very long pattern without throwing', async () => { + const result = await augment('a'.repeat(500), handle.dbPath); + expect(typeof result).toBe('string'); + }); + + it('handles unicode pattern without throwing', async () => { + const result = await augment('日本語テスト', handle.dbPath); + expect(typeof result).toBe('string'); + }); + }); +}, { + seed: AUGMENT_SEED_DATA, + ftsIndexes: AUGMENT_FTS_INDEXES, + poolAdapter: true, + afterSetup: async (handle) => { + // Configure mock to return our test DB so augment() can find it + const { listRegisteredRepos } = await import('../../src/storage/repo-manager.js'); + (listRegisteredRepos as ReturnType<typeof vi.fn>).mockResolvedValue([ + { + name: handle.repoId, + path: handle.dbPath, + storagePath: handle.tmpHandle.dbPath, + indexedAt: new Date().toISOString(), + lastCommit: 'abc123', + }, + ]); + + // Dynamically import augment after mocks are in place + const engine = await import('../../src/core/augmentation/engine.js'); + augment = engine.augment; + }, +}); diff --git a/gitnexus/test/integration/cli-e2e.test.ts b/gitnexus/test/integration/cli-e2e.test.ts new file mode 100644 index 0000000000..606e1a89f3 --- /dev/null +++ b/gitnexus/test/integration/cli-e2e.test.ts @@ -0,0 +1,408 @@ +/** + * P1 Integration Tests: CLI End-to-End + * + * Tests CLI commands via child process spawn: + * - statusCommand: verify stdout for unindexed repo + * - analyzeCommand: verify pipeline runs and creates .gitnexus/ output + * + * Uses process.execPath (never 'node' string), no shell: true. + * Accepts status === null (timeout) as valid on slow CI runners. + */ +import { describe, it, expect, beforeAll, afterAll } from 'vitest'; +import { spawnSync, spawn } from 'child_process'; +import path from 'path'; +import fs from 'fs'; +import os from 'os'; +import { fileURLToPath, pathToFileURL } from 'url'; + +import { createRequire } from 'module'; + +const testDir = path.dirname(fileURLToPath(import.meta.url)); +const repoRoot = path.resolve(testDir, '../..'); +const cliEntry = path.join(repoRoot, 'src/cli/index.ts'); +const MINI_REPO = path.resolve(testDir, '..', 'fixtures', 'mini-repo'); + +// Absolute file:// URL to tsx loader — needed when spawning CLI with cwd +// outside the project tree (bare 'tsx' specifier won't resolve there). +// Cannot use require.resolve('tsx/dist/loader.mjs') because the subpath is +// not in tsx's package.json exports; resolve the package root then join. +const _require = createRequire(import.meta.url); +const tsxPkgDir = path.dirname(_require.resolve('tsx/package.json')); +const tsxImportUrl = pathToFileURL(path.join(tsxPkgDir, 'dist', 'loader.mjs')).href; + +beforeAll(() => { + // Initialize mini-repo as a git repo so the CLI analyze command + // can run the full pipeline (it requires a .git directory). + const gitDir = path.join(MINI_REPO, '.git'); + if (!fs.existsSync(gitDir)) { + spawnSync('git', ['init'], { cwd: MINI_REPO, stdio: 'pipe' }); + spawnSync('git', ['add', '-A'], { cwd: MINI_REPO, stdio: 'pipe' }); + spawnSync('git', ['commit', '-m', 'initial commit'], { + cwd: MINI_REPO, + stdio: 'pipe', + env: { ...process.env, GIT_AUTHOR_NAME: 'test', GIT_AUTHOR_EMAIL: 'test@test', GIT_COMMITTER_NAME: 'test', GIT_COMMITTER_EMAIL: 'test@test' }, + }); + } +}); + +afterAll(() => { + // Clean up .git/ and .gitnexus/ directories created during the test + for (const dir of ['.git', '.gitnexus']) { + const fullPath = path.join(MINI_REPO, dir); + if (fs.existsSync(fullPath)) { + fs.rmSync(fullPath, { recursive: true, force: true }); + } + } +}); + +function runCli(command: string, cwd: string, timeoutMs = 15000) { + return spawnSync(process.execPath, ['--import', 'tsx', cliEntry, command], { + cwd, + encoding: 'utf8', + timeout: timeoutMs, + stdio: ['pipe', 'pipe', 'pipe'], + env: { + ...process.env, + // Pre-set --max-old-space-size so analyzeCommand's ensureHeap() sees it + // and skips the re-exec. The re-exec drops the tsx loader (--import tsx + // is not in process.argv), causing ERR_UNKNOWN_FILE_EXTENSION on .ts files. + NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=8192`.trim(), + }, + }); +} + +/** + * Like runCli but accepts an arbitrary extra-args array so unhappy-path tests + * can pass flags (e.g. --help) or omit a command entirely. + */ +function runCliRaw(extraArgs: string[], cwd: string, timeoutMs = 15000) { + return spawnSync(process.execPath, ['--import', 'tsx', cliEntry, ...extraArgs], { + cwd, + encoding: 'utf8', + timeout: timeoutMs, + stdio: ['pipe', 'pipe', 'pipe'], + env: { + ...process.env, + NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=8192`.trim(), + }, + }); +} + +describe('CLI end-to-end', () => { + it('status command exits cleanly', () => { + const result = runCli('status', MINI_REPO); + + // Accept timeout as valid on slow CI + if (result.status === null) return; + + expect(result.status).toBe(0); + const combined = result.stdout + result.stderr; + // mini-repo may or may not be indexed depending on prior test runs + expect(combined).toMatch(/Repository|not indexed/i); + }); + + it('analyze command runs pipeline on mini-repo', () => { + const result = runCli('analyze', MINI_REPO, 30000); + + // Accept timeout as valid on slow CI + if (result.status === null) return; + + expect(result.status, [ + `analyze exited with code ${result.status}`, + `stdout: ${result.stdout}`, + `stderr: ${result.stderr}`, + ].join('\n')).toBe(0); + + // Successful analyze should create .gitnexus/ output directory + const gitnexusDir = path.join(MINI_REPO, '.gitnexus'); + expect(fs.existsSync(gitnexusDir)).toBe(true); + expect(fs.statSync(gitnexusDir).isDirectory()).toBe(true); + }); + + describe('unhappy path', () => { + it('exits with error when no command is given', () => { + const result = runCliRaw([], MINI_REPO); + + // Accept timeout as valid on slow CI + if (result.status === null) return; + + // Commander exits with code 1 when no subcommand is given and + // prints a usage/error message to stderr. + expect(result.status).toBe(1); + const combined = result.stdout + result.stderr; + expect(combined.length).toBeGreaterThan(0); + }); + + it('shows help with --help flag', () => { + const result = runCliRaw(['--help'], MINI_REPO); + + // Accept timeout as valid on slow CI + if (result.status === null) return; + + expect(result.status).toBe(0); + // Commander writes --help output to stdout. + expect(result.stdout).toMatch(/Usage:/i); + // The program name and at least one known subcommand should appear. + expect(result.stdout).toMatch(/gitnexus/i); + expect(result.stdout).toMatch(/analyze|status|serve/i); + }); + + it('fails with unknown command', () => { + const result = runCliRaw(['nonexistent'], MINI_REPO); + + // Accept timeout as valid on slow CI + if (result.status === null) return; + + // Commander exits with code 1 and prints an error to stderr for unknown commands. + expect(result.status).toBe(1); + expect(result.stderr).toMatch(/unknown command/i); + }); + }); + + describe('CLI error handling', () => { + /** + * Helper to spawn CLI from a cwd outside the project tree. + * Uses the absolute file:// URL to tsx loader so the --import hook + * resolves even when cwd has no node_modules. + */ + function runCliOutsideProject(args: string[], cwd: string, timeoutMs = 15000) { + return spawnSync(process.execPath, ['--import', tsxImportUrl, cliEntry, ...args], { + cwd, + encoding: 'utf8', + timeout: timeoutMs, + stdio: ['pipe', 'pipe', 'pipe'], + env: { + ...process.env, + NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=8192`.trim(), + }, + }); + } + + it('status on non-indexed repo reports not indexed', () => { + // MINI_REPO is inside the project tree so findRepo() walks up and + // finds the parent project's .gitnexus. Use an isolated temp git + // repo to guarantee no .gitnexus exists anywhere in the path. + const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cli-noindex-')); + try { + spawnSync('git', ['init'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['commit', '--allow-empty', '-m', 'init'], { + cwd: tmpDir, stdio: 'pipe', + env: { ...process.env, GIT_AUTHOR_NAME: 'test', GIT_AUTHOR_EMAIL: 'test@test', GIT_COMMITTER_NAME: 'test', GIT_COMMITTER_EMAIL: 'test@test' }, + }); + + const result = runCliOutsideProject(['status'], tmpDir); + if (result.status === null) return; + + expect(result.status).toBe(0); + expect(result.stdout).toMatch(/Repository not indexed/); + } finally { + fs.rmSync(tmpDir, { recursive: true, force: true }); + } + }); + + it('status on non-git directory reports not a git repo', () => { + const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cli-nogit-')); + try { + const result = runCliOutsideProject(['status'], tmpDir); + if (result.status === null) return; + + // status.ts doesn't set process.exitCode — just prints and returns + expect(result.status).toBe(0); + expect(result.stdout).toMatch(/Not a git repository/); + } finally { + fs.rmSync(tmpDir, { recursive: true, force: true }); + } + }); + + it('analyze on non-git directory fails with exit code 1', () => { + const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cli-nogit-')); + try { + // Pass the non-git path as a separate argument via runCliRaw + // (runCli passes the whole string as one arg which breaks path parsing) + const result = runCliRaw(['analyze', tmpDir], repoRoot); + if (result.status === null) return; + + // analyze.ts sets process.exitCode = 1 for non-git paths + expect(result.status).toBe(1); + expect(result.stdout).toMatch(/not.*git repository/i); + } finally { + fs.rmSync(tmpDir, { recursive: true, force: true }); + } + }); + + }); + + // ─── stdout fd 1 tests (#324) ─────────────────────────────────────── + // These tests verify that tool output goes to stdout (fd 1), not stderr. + // Requires analyze to have run first (the analyze test above populates .gitnexus/). + + // All tool commands pass --repo to disambiguate when the global registry + // has multiple indexed repos (e.g. the parent project is also indexed). + describe('tool output goes to stdout via fd 1 (#324)', () => { + it('cypher: JSON appears on stdout, not stderr', () => { + const result = runCliRaw(['cypher', 'MATCH (n) RETURN n.name LIMIT 3', '--repo', 'mini-repo'], MINI_REPO); + if (result.status === null) return; // CI timeout tolerance + + expect(result.status).toBe(0); + + // stdout must contain valid JSON (array or object) + expect(() => JSON.parse(result.stdout.trim())).not.toThrow(); + + // stderr must NOT contain JSON — only human-readable diagnostics allowed + const stderrTrimmed = result.stderr.trim(); + if (stderrTrimmed.length > 0) { + expect(() => JSON.parse(stderrTrimmed)).toThrow(); + } + }); + + it('query: JSON appears on stdout, not stderr', () => { + // "handler" is a generic term likely to match something in mini-repo + const result = runCliRaw(['query', 'handler', '--repo', 'mini-repo'], MINI_REPO); + if (result.status === null) return; + + expect(result.status).toBe(0); + expect(() => JSON.parse(result.stdout.trim())).not.toThrow(); + }); + + it('impact: JSON appears on stdout, not stderr', () => { + const result = runCliRaw( + ['impact', 'handleRequest', '--direction', 'upstream', '--repo', 'mini-repo'], + MINI_REPO, + ); + if (result.status === null) return; + + expect(result.status).toBe(0); + // impact may return an error object (symbol not found) or a real result — + // either way it must be valid JSON on stdout + expect(() => JSON.parse(result.stdout.trim())).not.toThrow(); + }); + + it('stdout is pipeable: cypher output parses as valid JSON', () => { + const result = runCliRaw( + ['cypher', 'MATCH (n:Function) RETURN n.name LIMIT 5', '--repo', 'mini-repo'], + MINI_REPO, + ); + if (result.status === null) return; + + expect(result.status).toBe(0); + + // Simulate what jq does: parse stdout as JSON + const parsed = JSON.parse(result.stdout.trim()); + expect(Array.isArray(parsed) || typeof parsed === 'object').toBe(true); + }); + }); + + // ─── EPIPE clean exit test (#324) ─────────────────────────────────── + + describe('EPIPE handling (#324)', () => { + it('cypher: EPIPE exits with code 0, not stderr dump', () => { + return new Promise<void>((resolve, reject) => { + const child = spawn( + process.execPath, + ['--import', 'tsx', cliEntry, 'cypher', 'MATCH (n) RETURN n LIMIT 500', '--repo', 'mini-repo'], + { + cwd: MINI_REPO, + stdio: ['ignore', 'pipe', 'pipe'], + env: { + ...process.env, + NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=8192`.trim(), + }, + }, + ); + + let stderrOutput = ''; + child.stderr.on('data', (chunk: Buffer) => { stderrOutput += chunk.toString(); }); + + // Destroy stdout immediately — simulates `| head -0` (consumer closes early) + child.stdout.once('data', () => { + child.stdout.destroy(); // triggers EPIPE on next write + }); + + const timer = setTimeout(() => { + child.kill('SIGTERM'); + // Timeout is acceptable on CI — not a failure + resolve(); + }, 20000); + + child.on('close', (code) => { + clearTimeout(timer); + try { + // Clean EPIPE exit: code 0 + expect(code).toBe(0); + // No JSON payload should appear on stderr + const trimmed = stderrOutput.trim(); + if (trimmed.length > 0) { + expect(() => JSON.parse(trimmed)).toThrow(); + } + resolve(); + } catch (err) { + reject(err); + } + }); + }); + }, 25000); + }); + + // ─── eval-server READY signal test (#324) ─────────────────────────── + + describe('eval-server READY signal (#324)', () => { + it('READY signal appears on stdout, not stderr', () => { + return new Promise<void>((resolve, reject) => { + const child = spawn( + process.execPath, + ['--import', 'tsx', cliEntry, 'eval-server', '--port', '0', '--idle-timeout', '3'], + { + cwd: MINI_REPO, + stdio: ['ignore', 'pipe', 'pipe'], + env: { + ...process.env, + NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=8192`.trim(), + }, + }, + ); + + let stdoutBuffer = ''; + let foundOnStdout = false; + let foundOnStderr = false; + + child.stdout.on('data', (chunk: Buffer) => { + stdoutBuffer += chunk.toString(); + if (stdoutBuffer.includes('GITNEXUS_EVAL_SERVER_READY:')) { + foundOnStdout = true; + child.kill('SIGTERM'); + } + }); + + child.stderr.on('data', (chunk: Buffer) => { + const text = chunk.toString(); + if (text.includes('GITNEXUS_EVAL_SERVER_READY:')) { + foundOnStderr = true; + child.kill('SIGTERM'); + } + }); + + const timer = setTimeout(() => { + child.kill('SIGTERM'); + // Timeout is acceptable on CI — not a failure + resolve(); + }, 30000); + + child.on('close', () => { + clearTimeout(timer); + try { + if (foundOnStderr) { + reject(new Error('READY signal appeared on stderr instead of stdout')); + } else if (foundOnStdout) { + resolve(); + } else { + // eval-server may not start on all CI environments — don't fail + resolve(); + } + } catch (err) { + reject(err); + } + }); + }); + }, 35000); + }); +}); diff --git a/gitnexus/test/integration/csv-pipeline.test.ts b/gitnexus/test/integration/csv-pipeline.test.ts new file mode 100644 index 0000000000..2d8c880dd8 --- /dev/null +++ b/gitnexus/test/integration/csv-pipeline.test.ts @@ -0,0 +1,198 @@ +/** + * P1 Integration Tests: CSV Pipeline + * + * Tests: streamAllCSVsToDisk with real graph data. + * Covers hardening fixes: LRU cache (#24), BufferedCSVWriter flush + */ +import { describe, it, expect, beforeAll, afterAll } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import { createTempDir, type TestDBHandle } from '../helpers/test-db.js'; +import { buildTestGraph } from '../helpers/test-graph.js'; +import { streamAllCSVsToDisk } from '../../src/core/lbug/csv-generator.js'; + +let tmpHandle: TestDBHandle; +let csvDir: string; +let repoDir: string; + +beforeAll(async () => { + tmpHandle = await createTempDir('csv-pipeline-test-'); + csvDir = path.join(tmpHandle.dbPath, 'csv'); + repoDir = path.join(tmpHandle.dbPath, 'repo'); + + // Create a fake repo directory with source files + await fs.mkdir(path.join(repoDir, 'src'), { recursive: true }); + await fs.writeFile( + path.join(repoDir, 'src', 'index.ts'), + 'export function main() {\n console.log("hello");\n helper();\n}\n\nexport class App {\n run() {}\n}\n', + ); + await fs.writeFile( + path.join(repoDir, 'src', 'utils.ts'), + 'export function helper() {\n return 42;\n}\n', + ); +}); + +afterAll(async () => { + try { await tmpHandle.cleanup(); } catch { /* best-effort */ } +}); + +describe('streamAllCSVsToDisk', () => { + it('generates CSV files for all node types in the graph', async () => { + const graph = buildTestGraph( + [ + { id: 'file:src/index.ts', label: 'File', name: 'index.ts', filePath: 'src/index.ts' }, + { id: 'file:src/utils.ts', label: 'File', name: 'utils.ts', filePath: 'src/utils.ts' }, + { id: 'func:main', label: 'Function', name: 'main', filePath: 'src/index.ts', startLine: 1, endLine: 4, isExported: true }, + { id: 'func:helper', label: 'Function', name: 'helper', filePath: 'src/utils.ts', startLine: 1, endLine: 3, isExported: true }, + { id: 'class:App', label: 'Class', name: 'App', filePath: 'src/index.ts', startLine: 6, endLine: 8, isExported: true }, + { id: 'folder:src', label: 'Folder', name: 'src', filePath: 'src' }, + ], + [ + { sourceId: 'func:main', targetId: 'func:helper', type: 'CALLS' }, + { sourceId: 'file:src/index.ts', targetId: 'func:main', type: 'CONTAINS' }, + { sourceId: 'file:src/utils.ts', targetId: 'func:helper', type: 'CONTAINS' }, + ], + ); + + const result = await streamAllCSVsToDisk(graph, repoDir, csvDir); + + // Check that CSV files were created + expect(result.nodeFiles.size).toBeGreaterThan(0); + expect(result.relRows).toBe(3); + + // Verify File CSV + const fileCsv = result.nodeFiles.get('File'); + expect(fileCsv).toBeDefined(); + expect(fileCsv!.rows).toBe(2); + + // Verify Function CSV + const funcCsv = result.nodeFiles.get('Function'); + expect(funcCsv).toBeDefined(); + expect(funcCsv!.rows).toBe(2); + + // Verify Class CSV + const classCsv = result.nodeFiles.get('Class'); + expect(classCsv).toBeDefined(); + expect(classCsv!.rows).toBe(1); + + // Verify Folder CSV + const folderCsv = result.nodeFiles.get('Folder'); + expect(folderCsv).toBeDefined(); + expect(folderCsv!.rows).toBe(1); + + // Verify relations CSV exists + const relContent = await fs.readFile(result.relCsvPath, 'utf-8'); + const relLines = relContent.trim().split('\n'); + expect(relLines.length).toBe(4); // header + 3 relationships + }); + + it('CSV content is properly escaped', async () => { + const graph = buildTestGraph([ + { + id: 'file:src/index.ts', + label: 'File', + name: 'index.ts', + filePath: 'src/index.ts', + }, + ]); + + const result = await streamAllCSVsToDisk(graph, repoDir, csvDir); + const fileCsv = result.nodeFiles.get('File'); + expect(fileCsv).toBeDefined(); + + const content = await fs.readFile(fileCsv!.csvPath, 'utf-8'); + // Content should be properly quoted + expect(content).toContain('"file:src/index.ts"'); + expect(content).toContain('"index.ts"'); + }); + + it('handles community nodes with keywords', async () => { + const graph = buildTestGraph([ + { + id: 'comm:auth', + label: 'Community' as any, + name: 'Auth', + filePath: '', + extra: { + heuristicLabel: 'Authentication', + keywords: ['auth', 'login', 'pass,word'], + description: 'Auth module', + enrichedBy: 'heuristic', + cohesion: 0.85, + symbolCount: 5, + }, + }, + ]); + + const result = await streamAllCSVsToDisk(graph, repoDir, csvDir); + const commCsv = result.nodeFiles.get('Community'); + expect(commCsv).toBeDefined(); + expect(commCsv!.rows).toBe(1); + + const content = await fs.readFile(commCsv!.csvPath, 'utf-8'); + // Keywords with commas should be escaped with \, + expect(content).toContain('pass\\,word'); + }); + + it('handles process nodes', async () => { + const graph = buildTestGraph([ + { + id: 'proc:flow', + label: 'Process' as any, + name: 'LoginFlow', + filePath: '', + extra: { + heuristicLabel: 'User Login', + processType: 'intra_community', + stepCount: 3, + communities: ['auth'], + entryPointId: 'func:login', + terminalId: 'func:validate', + }, + }, + ]); + + const result = await streamAllCSVsToDisk(graph, repoDir, csvDir); + const procCsv = result.nodeFiles.get('Process'); + expect(procCsv).toBeDefined(); + expect(procCsv!.rows).toBe(1); + }); + + it('deduplicates File nodes', async () => { + const graph = buildTestGraph([ + { id: 'file:src/index.ts', label: 'File', name: 'index.ts', filePath: 'src/index.ts' }, + // Duplicate (same id) — should not appear twice + ]); + // Add the same node again manually + graph.addNode({ + id: 'file:src/index.ts', + label: 'File', + properties: { name: 'index.ts', filePath: 'src/index.ts' }, + }); + + const result = await streamAllCSVsToDisk(graph, repoDir, csvDir); + const fileCsv = result.nodeFiles.get('File'); + expect(fileCsv).toBeDefined(); + expect(fileCsv!.rows).toBe(1); + }); + + // ─── Unhappy paths ────────────────────────────────────────────────── + + it('handles empty graph (zero nodes)', async () => { + const graph = buildTestGraph([], []); + const result = await streamAllCSVsToDisk(graph, repoDir, csvDir); + expect(result.nodeFiles.size).toBe(0); + expect(result.relRows).toBe(0); + }); + + it('handles node with empty string properties', async () => { + const graph = buildTestGraph([ + { id: 'file:empty', label: 'File', name: '', filePath: '' }, + ]); + + const result = await streamAllCSVsToDisk(graph, repoDir, csvDir); + const fileCsv = result.nodeFiles.get('File'); + expect(fileCsv).toBeDefined(); + expect(fileCsv!.rows).toBe(1); + }); +}); diff --git a/gitnexus/test/integration/enrichment.test.ts b/gitnexus/test/integration/enrichment.test.ts new file mode 100644 index 0000000000..5b54eb2781 --- /dev/null +++ b/gitnexus/test/integration/enrichment.test.ts @@ -0,0 +1,235 @@ +/** + * Integration Tests: Cluster Enricher + * + * enrichClusters / enrichClustersBatch with mock LLM + * - Valid JSON response populates enrichments + * - Invalid JSON response falls back to heuristic label + * - Batch processing with enrichClustersBatch + * - Empty members use heuristicLabel fallback + */ +import { describe, it, expect, vi } from 'vitest'; +import { + enrichClusters, + enrichClustersBatch, + type LLMClient, + type ClusterMemberInfo, +} from '../../src/core/ingestion/cluster-enricher.js'; +import type { CommunityNode } from '../../src/core/ingestion/community-processor.js'; + +describe('enrichment', () => { + describe('enrichClusters', () => { + const communities: CommunityNode[] = [ + { + id: 'comm_0', + label: 'Auth', + heuristicLabel: 'Authentication', + cohesion: 0.8, + symbolCount: 3, + }, + { + id: 'comm_1', + label: 'Utils', + heuristicLabel: 'Utilities', + cohesion: 0.5, + symbolCount: 2, + }, + ]; + + const memberMap = new Map<string, ClusterMemberInfo[]>([ + [ + 'comm_0', + [ + { name: 'login', filePath: 'src/auth.ts', type: 'Function' }, + { name: 'validate', filePath: 'src/auth.ts', type: 'Function' }, + { name: 'AuthService', filePath: 'src/auth.ts', type: 'Class' }, + ], + ], + [ + 'comm_1', + [ + { name: 'hash', filePath: 'src/utils.ts', type: 'Function' }, + { name: 'format', filePath: 'src/utils.ts', type: 'Function' }, + ], + ], + ]); + + it('populates enrichments when LLM returns valid JSON', async () => { + const mockLLM: LLMClient = { + generate: vi.fn() + .mockResolvedValueOnce('{"name": "Auth Module", "description": "Handles authentication"}') + .mockResolvedValueOnce('{"name": "Utility Helpers", "description": "Common utilities"}'), + }; + + const result = await enrichClusters(communities, memberMap, mockLLM); + + expect(result.enrichments.size).toBe(2); + + const auth = result.enrichments.get('comm_0')!; + expect(auth.name).toBe('Auth Module'); + expect(auth.description).toBe('Handles authentication'); + + const utils = result.enrichments.get('comm_1')!; + expect(utils.name).toBe('Utility Helpers'); + expect(utils.description).toBe('Common utilities'); + + expect(result.tokensUsed).toBeGreaterThan(0); + expect(mockLLM.generate).toHaveBeenCalledTimes(2); + }); + + it('falls back to heuristic label when LLM returns invalid JSON', async () => { + const badLLM: LLMClient = { + generate: vi.fn().mockResolvedValue('this is not json at all'), + }; + + const result = await enrichClusters(communities, memberMap, badLLM); + + expect(result.enrichments.size).toBe(2); + + // Invalid JSON -> parseEnrichmentResponse falls back to heuristicLabel + const auth = result.enrichments.get('comm_0')!; + expect(auth.name).toBe('Authentication'); + expect(auth.keywords).toEqual([]); + expect(auth.description).toBe(''); + + const utils = result.enrichments.get('comm_1')!; + expect(utils.name).toBe('Utilities'); + }); + + it('uses heuristicLabel fallback for clusters with empty members', async () => { + const emptyMemberMap = new Map<string, ClusterMemberInfo[]>([ + ['comm_0', []], + ['comm_1', []], + ]); + + const mockLLM: LLMClient = { + generate: vi.fn().mockResolvedValue('{"name": "Should Not Appear", "description": "nope"}'), + }; + + const result = await enrichClusters(communities, emptyMemberMap, mockLLM); + + expect(result.enrichments.size).toBe(2); + + // Empty members -> skip LLM, use heuristic directly + const auth = result.enrichments.get('comm_0')!; + expect(auth.name).toBe('Authentication'); + expect(auth.keywords).toEqual([]); + expect(auth.description).toBe(''); + + // LLM should never be called for empty members + expect(mockLLM.generate).not.toHaveBeenCalled(); + }); + + it('calls onProgress callback with correct current/total', async () => { + const mockLLM: LLMClient = { + generate: vi.fn().mockResolvedValue('{"name": "X", "description": "Y"}'), + }; + const progress: Array<[number, number]> = []; + + await enrichClusters(communities, memberMap, mockLLM, (current, total) => { + progress.push([current, total]); + }); + + expect(progress).toEqual([ + [1, 2], + [2, 2], + ]); + }); + + // ─── Unhappy paths ──────────────────────────────────────────────── + + it('falls back to heuristic when LLM returns empty string', async () => { + const emptyLLM: LLMClient = { + generate: vi.fn().mockResolvedValue(''), + }; + + const result = await enrichClusters(communities, memberMap, emptyLLM); + expect(result.enrichments.size).toBe(2); + expect(result.enrichments.get('comm_0')!.name).toBe('Authentication'); + expect(result.enrichments.get('comm_1')!.name).toBe('Utilities'); + }); + + it('handles zero communities gracefully', async () => { + const mockLLM: LLMClient = { + generate: vi.fn(), + }; + + const result = await enrichClusters([], new Map(), mockLLM); + expect(result.enrichments.size).toBe(0); + expect(mockLLM.generate).not.toHaveBeenCalled(); + }); + + it('handles LLM returning JSON with missing description field', async () => { + const partialLLM: LLMClient = { + generate: vi.fn().mockResolvedValue('{"name": "Auth Only"}'), + }; + + const result = await enrichClusters(communities, memberMap, partialLLM); + expect(result.enrichments.size).toBe(2); + const auth = result.enrichments.get('comm_0')!; + expect(auth.name).toBe('Auth Only'); + }); + }); + + describe('enrichClustersBatch', () => { + const communities: CommunityNode[] = [ + { id: 'comm_0', label: 'Auth', heuristicLabel: 'Authentication', cohesion: 0.8, symbolCount: 3 }, + { id: 'comm_1', label: 'Utils', heuristicLabel: 'Utilities', cohesion: 0.5, symbolCount: 2 }, + { id: 'comm_2', label: 'Router', heuristicLabel: 'Routing', cohesion: 0.6, symbolCount: 2 }, + ]; + + const memberMap = new Map<string, ClusterMemberInfo[]>([ + ['comm_0', [{ name: 'login', filePath: 'src/auth.ts', type: 'Function' }]], + ['comm_1', [{ name: 'hash', filePath: 'src/utils.ts', type: 'Function' }]], + ['comm_2', [{ name: 'route', filePath: 'src/router.ts', type: 'Function' }]], + ]); + + it('processes all clusters in batches and returns enrichments', async () => { + const batchResponse = JSON.stringify([ + { id: 'comm_0', name: 'Auth Module', keywords: ['auth', 'login'], description: 'Authentication logic' }, + { id: 'comm_1', name: 'Utility Helpers', keywords: ['utils'], description: 'Common utilities' }, + ]); + const batchResponse2 = JSON.stringify([ + { id: 'comm_2', name: 'HTTP Router', keywords: ['routing'], description: 'Request routing' }, + ]); + + const mockLLM: LLMClient = { + generate: vi.fn() + .mockResolvedValueOnce(batchResponse) + .mockResolvedValueOnce(batchResponse2), + }; + + const result = await enrichClustersBatch(communities, memberMap, mockLLM, 2); + + expect(result.enrichments.size).toBe(3); + + const auth = result.enrichments.get('comm_0')!; + expect(auth.name).toBe('Auth Module'); + expect(auth.keywords).toEqual(['auth', 'login']); + expect(auth.description).toBe('Authentication logic'); + + const utils = result.enrichments.get('comm_1')!; + expect(utils.name).toBe('Utility Helpers'); + + const router = result.enrichments.get('comm_2')!; + expect(router.name).toBe('HTTP Router'); + + expect(result.tokensUsed).toBeGreaterThan(0); + // 3 communities with batchSize=2 -> 2 LLM calls + expect(mockLLM.generate).toHaveBeenCalledTimes(2); + }); + + it('falls back to heuristic labels on batch parse failure', async () => { + const mockLLM: LLMClient = { + generate: vi.fn().mockRejectedValue(new Error('LLM unavailable')), + }; + + const result = await enrichClustersBatch(communities, memberMap, mockLLM, 5); + + // All communities should get heuristic fallback + expect(result.enrichments.size).toBe(3); + expect(result.enrichments.get('comm_0')!.name).toBe('Authentication'); + expect(result.enrichments.get('comm_1')!.name).toBe('Utilities'); + expect(result.enrichments.get('comm_2')!.name).toBe('Routing'); + }); + }); +}); diff --git a/gitnexus/test/integration/filesystem-walker.test.ts b/gitnexus/test/integration/filesystem-walker.test.ts new file mode 100644 index 0000000000..fe50915a3f --- /dev/null +++ b/gitnexus/test/integration/filesystem-walker.test.ts @@ -0,0 +1,298 @@ +import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import os from 'os'; +import { walkRepositoryPaths, readFileContents } from '../../src/core/ingestion/filesystem-walker.js'; + +describe('filesystem-walker', () => { + let tmpDir: string; + + beforeAll(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-walker-test-')); + + // Create test directory structure + await fs.mkdir(path.join(tmpDir, 'src'), { recursive: true }); + await fs.mkdir(path.join(tmpDir, 'src', 'components'), { recursive: true }); + await fs.mkdir(path.join(tmpDir, 'node_modules', 'lodash'), { recursive: true }); + await fs.mkdir(path.join(tmpDir, '.git'), { recursive: true }); + + await fs.writeFile(path.join(tmpDir, 'src', 'index.ts'), 'export const main = () => {}'); + await fs.writeFile(path.join(tmpDir, 'src', 'utils.ts'), 'export const helper = () => {}'); + await fs.writeFile(path.join(tmpDir, 'src', 'components', 'Button.tsx'), 'export const Button = () => <div/>'); + await fs.writeFile(path.join(tmpDir, 'node_modules', 'lodash', 'index.js'), 'module.exports = {}'); + await fs.writeFile(path.join(tmpDir, '.git', 'HEAD'), 'ref: refs/heads/main'); + await fs.writeFile(path.join(tmpDir, 'package.json'), '{}'); + await fs.writeFile(path.join(tmpDir, 'src', 'image.png'), Buffer.from([0x89, 0x50, 0x4E, 0x47])); + }); + + afterAll(async () => { + try { + await fs.rm(tmpDir, { recursive: true, force: true }); + } catch { /* best-effort */ } + }); + + describe('walkRepositoryPaths', () => { + it('discovers source files', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + expect(paths.some(p => p.includes('src/index.ts'))).toBe(true); + expect(paths.some(p => p.includes('src/utils.ts'))).toBe(true); + }); + + it('discovers nested files', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + expect(paths.some(p => p.includes('components/Button.tsx'))).toBe(true); + }); + + it('skips node_modules', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + expect(paths.every(p => !p.includes('node_modules'))).toBe(true); + }); + + it('skips .git directory', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + expect(paths.every(p => !p.includes('.git/'))).toBe(true); + }); + + it('returns file sizes', async () => { + const files = await walkRepositoryPaths(tmpDir); + for (const file of files) { + expect(typeof file.size).toBe('number'); + expect(file.size).toBeGreaterThan(0); + } + }); + + it('calls progress callback', async () => { + const onProgress = vi.fn(); + await walkRepositoryPaths(tmpDir, onProgress); + expect(onProgress).toHaveBeenCalled(); + }); + + // ─── Unhappy paths ──────────────────────────────────────────────── + + it('throws or returns empty for non-existent directory', async () => { + try { + const files = await walkRepositoryPaths('/nonexistent/path/xyz123'); + // If it doesn't throw, it should return empty + expect(files).toEqual([]); + } catch (err: any) { + expect(err).toBeDefined(); + } + }); + + it('returns empty for directory with only ignored files', async () => { + const emptyDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-walker-empty-')); + await fs.mkdir(path.join(emptyDir, '.git'), { recursive: true }); + await fs.writeFile(path.join(emptyDir, '.git', 'HEAD'), 'ref: refs/heads/main'); + + try { + const files = await walkRepositoryPaths(emptyDir); + expect(files).toEqual([]); + } finally { + await fs.rm(emptyDir, { recursive: true, force: true }); + } + }); + + it('returns empty for truly empty directory', async () => { + const emptyDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-walker-truly-empty-')); + try { + const files = await walkRepositoryPaths(emptyDir); + expect(files).toEqual([]); + } finally { + await fs.rm(emptyDir, { recursive: true, force: true }); + } + }); + }); + + describe('.gitignore support', () => { + let gitignoreDir: string; + + beforeAll(async () => { + gitignoreDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-walker-gitignore-')); + + // Create directory structure + await fs.mkdir(path.join(gitignoreDir, 'src'), { recursive: true }); + await fs.mkdir(path.join(gitignoreDir, 'data', 'cache'), { recursive: true }); + await fs.mkdir(path.join(gitignoreDir, 'logs'), { recursive: true }); + + // Source files (should be indexed) + await fs.writeFile(path.join(gitignoreDir, 'src', 'index.ts'), 'export const main = () => {}'); + await fs.writeFile(path.join(gitignoreDir, 'src', 'utils.ts'), 'export const helper = () => {}'); + + // Data files (should be ignored via .gitignore) + await fs.writeFile(path.join(gitignoreDir, 'data', 'cache', 'file.json'), '{}'); + await fs.writeFile(path.join(gitignoreDir, 'logs', 'app.log'), 'log entry'); + + // .gitignore + await fs.writeFile(path.join(gitignoreDir, '.gitignore'), 'data/\nlogs/\n'); + }); + + afterAll(async () => { + await fs.rm(gitignoreDir, { recursive: true, force: true }); + }); + + it('excludes directories listed in .gitignore', async () => { + const files = await walkRepositoryPaths(gitignoreDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + // Source files should be present + expect(paths.some(p => p.includes('src/index.ts'))).toBe(true); + expect(paths.some(p => p.includes('src/utils.ts'))).toBe(true); + + // Ignored directories should not be present + expect(paths.every(p => !p.includes('data/'))).toBe(true); + expect(paths.every(p => !p.includes('logs/'))).toBe(true); + }); + + it('still applies hardcoded ignore list alongside .gitignore', async () => { + // Add node_modules (hardcoded ignore) to verify both work + await fs.mkdir(path.join(gitignoreDir, 'node_modules', 'pkg'), { recursive: true }); + await fs.writeFile(path.join(gitignoreDir, 'node_modules', 'pkg', 'index.js'), 'module.exports = {}'); + + const files = await walkRepositoryPaths(gitignoreDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + expect(paths.every(p => !p.includes('node_modules'))).toBe(true); + expect(paths.every(p => !p.includes('data/'))).toBe(true); + + await fs.rm(path.join(gitignoreDir, 'node_modules'), { recursive: true, force: true }); + }); + }); + + describe('.gitnexusignore support', () => { + let nexusignoreDir: string; + + beforeAll(async () => { + nexusignoreDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-walker-nexusignore-')); + + await fs.mkdir(path.join(nexusignoreDir, 'src'), { recursive: true }); + await fs.mkdir(path.join(nexusignoreDir, 'local', 'grafana'), { recursive: true }); + + await fs.writeFile(path.join(nexusignoreDir, 'src', 'index.ts'), 'export const main = () => {}'); + await fs.writeFile(path.join(nexusignoreDir, 'local', 'grafana', 'module.js'), 'var x = 1;'); + + // Only .gitnexusignore, no .gitignore + await fs.writeFile(path.join(nexusignoreDir, '.gitnexusignore'), 'local/\n'); + }); + + afterAll(async () => { + await fs.rm(nexusignoreDir, { recursive: true, force: true }); + }); + + it('excludes directories listed in .gitnexusignore', async () => { + const files = await walkRepositoryPaths(nexusignoreDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + expect(paths.some(p => p.includes('src/index.ts'))).toBe(true); + expect(paths.every(p => !p.includes('local/'))).toBe(true); + }); + }); + + describe('combined .gitignore + .gitnexusignore', () => { + let combinedDir: string; + + beforeAll(async () => { + combinedDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-walker-combined-')); + + await fs.mkdir(path.join(combinedDir, 'src'), { recursive: true }); + await fs.mkdir(path.join(combinedDir, 'data'), { recursive: true }); + await fs.mkdir(path.join(combinedDir, 'local', 'plugins'), { recursive: true }); + + await fs.writeFile(path.join(combinedDir, 'src', 'index.ts'), 'export const main = () => {}'); + await fs.writeFile(path.join(combinedDir, 'data', 'dump.json'), '{}'); + await fs.writeFile(path.join(combinedDir, 'local', 'plugins', 'module.js'), 'var x = 1;'); + + await fs.writeFile(path.join(combinedDir, '.gitignore'), 'data/\n'); + await fs.writeFile(path.join(combinedDir, '.gitnexusignore'), 'local/\n'); + }); + + afterAll(async () => { + await fs.rm(combinedDir, { recursive: true, force: true }); + }); + + it('excludes directories from both files', async () => { + const files = await walkRepositoryPaths(combinedDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + expect(paths.some(p => p.includes('src/index.ts'))).toBe(true); + expect(paths.every(p => !p.includes('data/'))).toBe(true); + expect(paths.every(p => !p.includes('local/'))).toBe(true); + }); + }); + + describe('GITNEXUS_NO_GITIGNORE env var', () => { + let envDir: string; + + beforeAll(async () => { + envDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-walker-noignore-')); + + await fs.mkdir(path.join(envDir, 'src'), { recursive: true }); + await fs.mkdir(path.join(envDir, 'data'), { recursive: true }); + + await fs.writeFile(path.join(envDir, 'src', 'index.ts'), 'export const main = () => {}'); + await fs.writeFile(path.join(envDir, 'data', 'dump.json'), '{}'); + + await fs.writeFile(path.join(envDir, '.gitignore'), 'data/\n'); + }); + + afterAll(async () => { + await fs.rm(envDir, { recursive: true, force: true }); + }); + + it('excludes gitignored directory by default', async () => { + const files = await walkRepositoryPaths(envDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + expect(paths.every(p => !p.includes('data/'))).toBe(true); + }); + + it('includes gitignored directory when GITNEXUS_NO_GITIGNORE is set', async () => { + const original = process.env.GITNEXUS_NO_GITIGNORE; + process.env.GITNEXUS_NO_GITIGNORE = '1'; + try { + const files = await walkRepositoryPaths(envDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + expect(paths.some(p => p.includes('data/dump.json'))).toBe(true); + } finally { + if (original === undefined) { + delete process.env.GITNEXUS_NO_GITIGNORE; + } else { + process.env.GITNEXUS_NO_GITIGNORE = original; + } + } + }); + }); + + describe('readFileContents', () => { + it('reads file contents by relative paths', async () => { + const contents = await readFileContents(tmpDir, ['src/index.ts', 'src/utils.ts']); + expect(contents.get('src/index.ts')).toContain('main'); + expect(contents.get('src/utils.ts')).toContain('helper'); + }); + + it('handles empty path list', async () => { + const contents = await readFileContents(tmpDir, []); + expect(contents.size).toBe(0); + }); + + it('skips non-existent files gracefully', async () => { + const contents = await readFileContents(tmpDir, ['nonexistent.ts']); + expect(contents.size).toBe(0); + }); + + // ─── Unhappy paths ──────────────────────────────────────────────── + + it('skips multiple non-existent files gracefully', async () => { + const contents = await readFileContents(tmpDir, ['a.ts', 'b.ts', 'c.ts']); + expect(contents.size).toBe(0); + }); + + it('handles binary file content without crashing', async () => { + const contents = await readFileContents(tmpDir, ['src/image.png']); + // May return content or skip — should not throw + expect(contents.size).toBeLessThanOrEqual(1); + }); + }); +}); diff --git a/gitnexus/test/integration/has-method.test.ts b/gitnexus/test/integration/has-method.test.ts new file mode 100644 index 0000000000..5e948e48d9 --- /dev/null +++ b/gitnexus/test/integration/has-method.test.ts @@ -0,0 +1,531 @@ +/** + * Integration tests for HAS_METHOD edge extraction. + * + * These tests exercise findEnclosingClassId against real tree-sitter ASTs + * produced by the actual parser pipeline (loadParser + loadLanguage + queries). + * Unlike the unit tests that test findEnclosingClassId in isolation with simple + * snippets, these focus on multi-class files, interface vs class disambiguation, + * and cross-language pipeline correctness. + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import Parser from 'tree-sitter'; +import { loadParser, loadLanguage } from '../../src/core/tree-sitter/parser-loader.js'; +import { LANGUAGE_QUERIES } from '../../src/core/ingestion/tree-sitter-queries.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; +import { + findEnclosingClassId, + DEFINITION_CAPTURE_KEYS, + getDefinitionNodeFromCaptures, +} from '../../src/core/ingestion/utils.js'; + +let parser: Parser; + +beforeAll(async () => { + parser = await loadParser(); +}); + +/** Parse code with given language, run definition queries, return matched definitions with their enclosing class IDs. */ +function parseAndExtractMethods( + code: string, + lang: SupportedLanguages, + filePath: string, +): { name: string; defType: string; enclosingClassId: string | null }[] { + const tree = parser.parse(code); + const query = new Parser.Query(parser.getLanguage(), LANGUAGE_QUERIES[lang]); + const matches = query.matches(tree.rootNode); + + const results: { name: string; defType: string; enclosingClassId: string | null }[] = []; + + for (const match of matches) { + const captureMap: Record<string, any> = {}; + let nameNode: any = null; + + for (const capture of match.captures) { + captureMap[capture.name] = capture.node; + if (capture.name === 'name') { + nameNode = capture.node; + } + } + + const defNode = getDefinitionNodeFromCaptures(captureMap); + if (!defNode || !nameNode) continue; + + const defType = Object.keys(captureMap).find(k => k.startsWith('definition.')) || 'unknown'; + const enclosingClassId = findEnclosingClassId(nameNode, filePath); + + results.push({ + name: nameNode.text, + defType, + enclosingClassId, + }); + } + + return results; +} + +describe('HAS_METHOD integration — C#: class with interface', () => { + beforeAll(async () => { + await loadLanguage(SupportedLanguages.CSharp); + }); + + it('methods link to correct owner (interface vs class)', () => { + const code = ` +interface IRepository { + void FindById(int id); + void Save(object entity); +} + +class SqlRepository { + public void FindById(int id) {} + public void Save(object entity) {} + private void Connect() {} +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.CSharp, 'src/Repo.cs'); + + // Interface methods should be enclosed by the interface + const ifaceFindById = results.find(r => r.name === 'FindById' && r.enclosingClassId?.startsWith('Interface:')); + expect(ifaceFindById).toBeDefined(); + expect(ifaceFindById!.enclosingClassId).toBe('Interface:src/Repo.cs:IRepository'); + + const ifaceSave = results.find(r => r.name === 'Save' && r.enclosingClassId?.startsWith('Interface:')); + expect(ifaceSave).toBeDefined(); + expect(ifaceSave!.enclosingClassId).toBe('Interface:src/Repo.cs:IRepository'); + + // Class methods should be enclosed by the class + const classFindById = results.find(r => r.name === 'FindById' && r.enclosingClassId?.startsWith('Class:')); + expect(classFindById).toBeDefined(); + expect(classFindById!.enclosingClassId).toBe('Class:src/Repo.cs:SqlRepository'); + + const classConnect = results.find(r => r.name === 'Connect'); + expect(classConnect).toBeDefined(); + expect(classConnect!.enclosingClassId).toBe('Class:src/Repo.cs:SqlRepository'); + }); + + it('class/interface name captures point to their own container (self-referential)', () => { + const code = ` +interface IService { + void Execute(); +} + +class ServiceImpl { + public void Execute() {} +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.CSharp, 'src/Service.cs'); + + // The name node for IService sits inside the interface_declaration, so + // findEnclosingClassId returns the interface itself. This is expected — + // the pipeline uses defType (definition.interface vs definition.method) to + // distinguish container declarations from methods, not enclosingClassId. + const ifaceDecl = results.find(r => r.name === 'IService'); + expect(ifaceDecl).toBeDefined(); + expect(ifaceDecl!.defType).toBe('definition.interface'); + + const classDecl = results.find(r => r.name === 'ServiceImpl'); + expect(classDecl).toBeDefined(); + expect(classDecl!.defType).toBe('definition.class'); + + // Methods should still correctly reference their container + const execMethods = results.filter(r => r.name === 'Execute'); + expect(execMethods.length).toBe(2); + expect(execMethods.some(r => r.enclosingClassId === 'Interface:src/Service.cs:IService')).toBe(true); + expect(execMethods.some(r => r.enclosingClassId === 'Class:src/Service.cs:ServiceImpl')).toBe(true); + }); +}); + +describe('HAS_METHOD integration — Rust: impl + trait', () => { + beforeAll(async () => { + await loadLanguage(SupportedLanguages.Rust); + }); + + it('methods link to impl vs trait nodes', () => { + const code = ` +trait Drawable { + fn draw(&self); + fn resize(&self, w: u32, h: u32); +} + +struct Circle { + radius: f64, +} + +impl Circle { + fn new(radius: f64) -> Circle { + Circle { radius } + } + + fn area(&self) -> f64 { + 3.14 * self.radius * self.radius + } +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.Rust, 'src/shapes.rs'); + + // Trait methods should be enclosed by the trait + const traitDraw = results.find(r => r.name === 'draw'); + if (traitDraw) { + expect(traitDraw.enclosingClassId).toBe('Trait:src/shapes.rs:Drawable'); + } + + const traitResize = results.find(r => r.name === 'resize'); + if (traitResize) { + expect(traitResize.enclosingClassId).toBe('Trait:src/shapes.rs:Drawable'); + } + + // Impl methods should be enclosed by the impl block + const implNew = results.find(r => r.name === 'new'); + if (implNew) { + expect(implNew.enclosingClassId).toBe('Impl:src/shapes.rs:Circle'); + } + + const implArea = results.find(r => r.name === 'area'); + if (implArea) { + expect(implArea.enclosingClassId).toBe('Impl:src/shapes.rs:Circle'); + } + }); + + it('standalone functions do not get HAS_METHOD', () => { + const code = ` +fn helper() -> bool { + true +} + +struct Foo; + +impl Foo { + fn bar(&self) {} +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.Rust, 'src/lib.rs'); + + const helper = results.find(r => r.name === 'helper'); + expect(helper).toBeDefined(); + expect(helper!.enclosingClassId).toBeNull(); + + const bar = results.find(r => r.name === 'bar'); + if (bar) { + expect(bar.enclosingClassId).toBe('Impl:src/lib.rs:Foo'); + } + }); +}); + +describe('HAS_METHOD integration — Python: class methods vs standalone functions', () => { + beforeAll(async () => { + await loadLanguage(SupportedLanguages.Python); + }); + + it('methods link to class, standalone functions get null', () => { + const code = ` +def standalone_helper(): + return 42 + +class Calculator: + def __init__(self): + self.value = 0 + + def add(self, x): + self.value += x + return self + + def result(self): + return self.value + +def another_standalone(): + pass +`; + const results = parseAndExtractMethods(code, SupportedLanguages.Python, 'src/calc.py'); + + // Standalone functions should not be enclosed + const standaloneHelper = results.find(r => r.name === 'standalone_helper'); + expect(standaloneHelper).toBeDefined(); + expect(standaloneHelper!.enclosingClassId).toBeNull(); + + const anotherStandalone = results.find(r => r.name === 'another_standalone'); + expect(anotherStandalone).toBeDefined(); + expect(anotherStandalone!.enclosingClassId).toBeNull(); + + // Class methods should be enclosed + const init = results.find(r => r.name === '__init__'); + expect(init).toBeDefined(); + expect(init!.enclosingClassId).toBe('Class:src/calc.py:Calculator'); + + const add = results.find(r => r.name === 'add'); + expect(add).toBeDefined(); + expect(add!.enclosingClassId).toBe('Class:src/calc.py:Calculator'); + + const resultMethod = results.find(r => r.name === 'result'); + expect(resultMethod).toBeDefined(); + expect(resultMethod!.enclosingClassId).toBe('Class:src/calc.py:Calculator'); + }); +}); + +describe('HAS_METHOD integration — Multiple classes in one file', () => { + describe('TypeScript', () => { + beforeAll(async () => { + await loadLanguage(SupportedLanguages.TypeScript, 'multi.ts'); + }); + + it('methods associate with their owning class', () => { + const code = ` +class UserService { + findUser(id: number) { + return null; + } + deleteUser(id: number) {} +} + +class OrderService { + createOrder(data: any) { + return data; + } + cancelOrder(id: number) {} +} + +function topLevelUtil() { + return true; +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.TypeScript, 'src/services.ts'); + + // UserService methods + const findUser = results.find(r => r.name === 'findUser'); + expect(findUser).toBeDefined(); + expect(findUser!.enclosingClassId).toBe('Class:src/services.ts:UserService'); + + const deleteUser = results.find(r => r.name === 'deleteUser'); + expect(deleteUser).toBeDefined(); + expect(deleteUser!.enclosingClassId).toBe('Class:src/services.ts:UserService'); + + // OrderService methods + const createOrder = results.find(r => r.name === 'createOrder'); + expect(createOrder).toBeDefined(); + expect(createOrder!.enclosingClassId).toBe('Class:src/services.ts:OrderService'); + + const cancelOrder = results.find(r => r.name === 'cancelOrder'); + expect(cancelOrder).toBeDefined(); + expect(cancelOrder!.enclosingClassId).toBe('Class:src/services.ts:OrderService'); + + // Top-level function + const topLevelUtil = results.find(r => r.name === 'topLevelUtil'); + expect(topLevelUtil).toBeDefined(); + expect(topLevelUtil!.enclosingClassId).toBeNull(); + }); + }); + + describe('Java', () => { + beforeAll(async () => { + await loadLanguage(SupportedLanguages.Java); + }); + + it('methods associate with their owning class', () => { + const code = ` +class Logger { + public void info(String msg) {} + public void error(String msg) {} +} + +class Formatter { + public String format(String template) { return template; } + private String escape(String input) { return input; } +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.Java, 'src/util/Logging.java'); + + const info = results.find(r => r.name === 'info'); + expect(info).toBeDefined(); + expect(info!.enclosingClassId).toBe('Class:src/util/Logging.java:Logger'); + + const error = results.find(r => r.name === 'error'); + expect(error).toBeDefined(); + expect(error!.enclosingClassId).toBe('Class:src/util/Logging.java:Logger'); + + const format = results.find(r => r.name === 'format'); + expect(format).toBeDefined(); + expect(format!.enclosingClassId).toBe('Class:src/util/Logging.java:Formatter'); + + const escape = results.find(r => r.name === 'escape'); + expect(escape).toBeDefined(); + expect(escape!.enclosingClassId).toBe('Class:src/util/Logging.java:Formatter'); + }); + }); +}); + +describe('HAS_METHOD integration — Java: class with interface', () => { + beforeAll(async () => { + await loadLanguage(SupportedLanguages.Java); + }); + + it('methods link to correct owner (interface vs class)', () => { + const code = ` +interface Validator { + boolean validate(Object input); + String getMessage(); +} + +class EmailValidator { + public boolean validate(Object input) { return true; } + public String getMessage() { return "invalid email"; } + private boolean checkFormat(String email) { return true; } +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.Java, 'src/validation/Validator.java'); + + // Interface methods + const ifaceValidate = results.find(r => r.name === 'validate' && r.enclosingClassId?.startsWith('Interface:')); + expect(ifaceValidate).toBeDefined(); + expect(ifaceValidate!.enclosingClassId).toBe('Interface:src/validation/Validator.java:Validator'); + + const ifaceGetMessage = results.find(r => r.name === 'getMessage' && r.enclosingClassId?.startsWith('Interface:')); + expect(ifaceGetMessage).toBeDefined(); + expect(ifaceGetMessage!.enclosingClassId).toBe('Interface:src/validation/Validator.java:Validator'); + + // Class methods + const classValidate = results.find(r => r.name === 'validate' && r.enclosingClassId?.startsWith('Class:')); + expect(classValidate).toBeDefined(); + expect(classValidate!.enclosingClassId).toBe('Class:src/validation/Validator.java:EmailValidator'); + + const classCheckFormat = results.find(r => r.name === 'checkFormat'); + expect(classCheckFormat).toBeDefined(); + expect(classCheckFormat!.enclosingClassId).toBe('Class:src/validation/Validator.java:EmailValidator'); + }); + + it('class/interface declarations are captured with correct defType', () => { + const code = ` +interface Repository { + void save(Object entity); +} + +class UserRepository { + public void save(Object entity) {} +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.Java, 'src/repo/Repo.java'); + + // The pipeline distinguishes containers from methods via defType, not enclosingClassId + const repoDecl = results.find(r => r.name === 'Repository'); + expect(repoDecl).toBeDefined(); + expect(repoDecl!.defType).toBe('definition.interface'); + + const userRepoDecl = results.find(r => r.name === 'UserRepository'); + expect(userRepoDecl).toBeDefined(); + expect(userRepoDecl!.defType).toBe('definition.class'); + + // Methods associate correctly + const saveMethods = results.filter(r => r.name === 'save'); + expect(saveMethods.length).toBe(2); + expect(saveMethods.some(r => r.enclosingClassId === 'Interface:src/repo/Repo.java:Repository')).toBe(true); + expect(saveMethods.some(r => r.enclosingClassId === 'Class:src/repo/Repo.java:UserRepository')).toBe(true); + }); +}); + +describe('HAS_METHOD integration — C++ class methods', () => { + beforeAll(async () => { + await loadLanguage(SupportedLanguages.CPlusPlus); + }); + + it('inline methods link to their owning class_specifier', () => { + const code = ` +class Stack { +public: + void push(int val) { data[top++] = val; } + int pop() { return data[--top]; } + int size() { return top; } +private: + int data[100]; + int top; +}; + +class Queue { +public: + void enqueue(int val) {} + int dequeue() { return 0; } +}; +`; + const results = parseAndExtractMethods(code, SupportedLanguages.CPlusPlus, 'src/containers.h'); + + // Stack methods + const push = results.find(r => r.name === 'push'); + if (push) { + expect(push.enclosingClassId).toBe('Class:src/containers.h:Stack'); + } + + const pop = results.find(r => r.name === 'pop'); + if (pop) { + expect(pop.enclosingClassId).toBe('Class:src/containers.h:Stack'); + } + + const size = results.find(r => r.name === 'size'); + if (size) { + expect(size.enclosingClassId).toBe('Class:src/containers.h:Stack'); + } + + // Queue methods + const enqueue = results.find(r => r.name === 'enqueue'); + if (enqueue) { + expect(enqueue.enclosingClassId).toBe('Class:src/containers.h:Queue'); + } + + const dequeue = results.find(r => r.name === 'dequeue'); + if (dequeue) { + expect(dequeue.enclosingClassId).toBe('Class:src/containers.h:Queue'); + } + }); + + it('free functions have null enclosingClassId', () => { + const code = ` +void freeFunction() {} + +class Foo { +public: + void method() {} +}; +`; + const results = parseAndExtractMethods(code, SupportedLanguages.CPlusPlus, 'src/mixed.cpp'); + + const freeFn = results.find(r => r.name === 'freeFunction'); + if (freeFn) { + expect(freeFn.enclosingClassId).toBeNull(); + } + + const method = results.find(r => r.name === 'method'); + if (method) { + expect(method.enclosingClassId).toBe('Class:src/mixed.cpp:Foo'); + } + }); +}); + +describe('HAS_METHOD integration — C# struct and record', () => { + beforeAll(async () => { + await loadLanguage(SupportedLanguages.CSharp); + }); + + it('struct methods link to struct, record methods link to record', () => { + const code = ` +struct Vector2 { + public float Length() { return 0; } + public Vector2 Normalize() { return this; } +} + +record Person { + public string GetFullName() { return ""; } +} +`; + const results = parseAndExtractMethods(code, SupportedLanguages.CSharp, 'src/Types.cs'); + + const length = results.find(r => r.name === 'Length'); + if (length) { + expect(length.enclosingClassId).toBe('Struct:src/Types.cs:Vector2'); + } + + const normalize = results.find(r => r.name === 'Normalize'); + if (normalize) { + expect(normalize.enclosingClassId).toBe('Struct:src/Types.cs:Vector2'); + } + + const getFullName = results.find(r => r.name === 'GetFullName'); + if (getFullName) { + expect(getFullName.enclosingClassId).toBe('Record:src/Types.cs:Person'); + } + }); +}); diff --git a/gitnexus/test/integration/hooks-e2e.test.ts b/gitnexus/test/integration/hooks-e2e.test.ts new file mode 100644 index 0000000000..a53e646dd6 --- /dev/null +++ b/gitnexus/test/integration/hooks-e2e.test.ts @@ -0,0 +1,411 @@ +/** + * Integration Tests: Claude Code Hooks End-to-End + * + * Tests the hook scripts with real git repos and .gitnexus directories. + * Unlike unit/hooks.test.ts which tests source code patterns and simple + * stdin/stdout, these tests verify actual behavior with filesystem state. + */ +import { describe, it, expect, beforeAll, afterAll } from 'vitest'; +import { spawnSync } from 'child_process'; +import fs from 'fs'; +import path from 'path'; +import os from 'os'; +import { runHook, parseHookOutput } from '../utils/hook-test-helpers.js'; + +// ─── Paths to both hook variants ──────────────────────────────────── + +const CJS_HOOK = path.resolve(__dirname, '..', '..', 'hooks', 'claude', 'gitnexus-hook.cjs'); +const PLUGIN_HOOK = path.resolve(__dirname, '..', '..', '..', 'gitnexus-claude-plugin', 'hooks', 'gitnexus-hook.js'); + +const HOOKS = [ + { name: 'CJS', path: CJS_HOOK }, + ...(fs.existsSync(PLUGIN_HOOK) ? [{ name: 'Plugin', path: PLUGIN_HOOK }] : []), +]; + +// ─── Temp git repo with .gitnexus ─────────────────────────────────── + +let tmpDir: string; +let gitNexusDir: string; + +beforeAll(() => { + tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-e2e-')); + gitNexusDir = path.join(tmpDir, '.gitnexus'); + fs.mkdirSync(gitNexusDir, { recursive: true }); + + // Initialize a real git repo + spawnSync('git', ['init'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['config', 'user.email', 'test@test.com'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['config', 'user.name', 'Test'], { cwd: tmpDir, stdio: 'pipe' }); + + // Create a file and commit so HEAD exists + fs.writeFileSync(path.join(tmpDir, 'hello.txt'), 'hello'); + spawnSync('git', ['add', '.'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['commit', '-m', 'init'], { cwd: tmpDir, stdio: 'pipe' }); +}); + +afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); +}); + +// ─── Tests ────────────────────────────────────────────────────────── + +describe.each(HOOKS)('hooks e2e ($name)', ({ name, path: hookPath }) => { + describe('PostToolUse staleness detection', () => { + it('detects stale index when meta.json lastCommit differs from HEAD', () => { + // Write meta.json with an old commit hash + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).toContain('stale'); + expect(output!.additionalContext).toContain('npx gitnexus analyze'); + }); + + it('stays silent when meta.json lastCommit matches HEAD', () => { + // Get current HEAD + const headResult = spawnSync('git', ['rev-parse', 'HEAD'], { + cwd: tmpDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], + }); + const head = headResult.stdout.trim(); + + // Write meta.json with matching commit + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: head, stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + + it('includes --embeddings flag when previous index had embeddings', () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', stats: { embeddings: 42 } }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).toContain('--embeddings'); + }); + + it('treats missing meta.json as stale', () => { + // Remove meta.json + const metaPath = path.join(gitNexusDir, 'meta.json'); + if (fs.existsSync(metaPath)) fs.unlinkSync(metaPath); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).toContain('stale'); + }); + + it('ignores failed git commands (exit_code !== 0)', () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'cccccccccccccccccccccccccccccccccccccccc', stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 1 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + + it('ignores non-mutation git commands', () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'dddddddddddddddddddddddddddddddddddddddd', stats: {} }), + ); + + const nonMutations = ['git status', 'git log', 'git diff', 'git branch', 'git stash']; + for (const cmd of nonMutations) { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: cmd }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + } + }); + + it('detects all 5 git mutation types', () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', stats: {} }), + ); + + const mutations = ['git commit -m "x"', 'git merge feature', 'git rebase main', 'git cherry-pick abc', 'git pull origin main']; + for (const cmd of mutations) { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: cmd }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).toContain('stale'); + } + }); + }); + + describe('PreToolUse — silent without gitnexus CLI', () => { + // PreToolUse tries to spawn `gitnexus augment` which won't be available in CI. + // Verify it fails gracefully (no output, no crash). + + it('handles Grep pattern gracefully when CLI is unavailable', () => { + const result = runHook(hookPath, { + hook_event_name: 'PreToolUse', + tool_name: 'Grep', + tool_input: { pattern: 'handleRequest' }, + cwd: tmpDir, + }); + + // Should not crash — status is 0 if it exits cleanly, or null if the + // spawned `gitnexus augment` hangs and the 10s timeout kills the process. + expect(result.status === 0 || result.status === null).toBe(true); + }); + + it('ignores patterns shorter than 3 chars', () => { + const result = runHook(hookPath, { + hook_event_name: 'PreToolUse', + tool_name: 'Grep', + tool_input: { pattern: 'ab' }, + cwd: tmpDir, + }); + + expect(result.status).toBe(0); + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + + it('ignores non-search tools', () => { + const result = runHook(hookPath, { + hook_event_name: 'PreToolUse', + tool_name: 'Read', + tool_input: { file_path: '/some/file.ts' }, + cwd: tmpDir, + }); + + expect(result.status).toBe(0); + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + }); + + describe('cwd validation', () => { + it('rejects relative cwd silently for PostToolUse', () => { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "x"' }, + tool_output: { exit_code: 0 }, + cwd: 'relative/path', + }); + + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + + it('rejects relative cwd silently for PreToolUse', () => { + const result = runHook(hookPath, { + hook_event_name: 'PreToolUse', + tool_name: 'Grep', + tool_input: { pattern: 'testPattern' }, + cwd: 'relative/path', + }); + + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + }); + + describe('unhappy paths', () => { + it('handles corrupted meta.json (invalid JSON) without crashing', () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + 'THIS IS NOT JSON {{{', + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + // Should not crash — either treats as stale or ignores + expect(result.status === 0 || result.status === null).toBe(true); + }); + + it('handles meta.json with missing lastCommit field', () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + expect(result.status === 0 || result.status === null).toBe(true); + const output = parseHookOutput(result.stdout); + // Missing lastCommit should be treated as stale + if (output) { + expect(output.additionalContext).toContain('stale'); + } + }); + + it('ignores unknown hook event name', () => { + const result = runHook(hookPath, { + hook_event_name: 'UnknownEvent', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + expect(result.status).toBe(0); + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + + it('handles empty tool_input for PostToolUse without crashing', () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'aaaa', stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: {}, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + expect(result.status === 0 || result.status === null).toBe(true); + const output = parseHookOutput(result.stdout); + // No command means no git mutation detection — should be silent + expect(output).toBeNull(); + }); + + it('ignores non-Bash tool for PostToolUse', () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'aaaa', stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Read', + tool_input: { file_path: '/some/file.ts' }, + tool_output: {}, + cwd: tmpDir, + }); + + expect(result.status).toBe(0); + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + }); + + describe('directory without .gitnexus', () => { + // The hook walks up 5 parent directories looking for .gitnexus. + // To guarantee none is found, create a deeply nested temp dir at the + // filesystem root where no .gitnexus could exist in any ancestor. + let noGitNexusDir: string; + + beforeAll(() => { + // Use a root-level temp path so parent traversal can't find .gitnexus + const root = os.platform() === 'win32' ? 'C:\\' : '/tmp'; + const base = path.join(root, `no-gitnexus-${Date.now()}`); + // Nest 6 levels deep (hook walks up 5) to ensure isolation + noGitNexusDir = path.join(base, 'a', 'b', 'c', 'd', 'e', 'f'); + fs.mkdirSync(noGitNexusDir, { recursive: true }); + spawnSync('git', ['init'], { cwd: noGitNexusDir, stdio: 'pipe' }); + }); + + afterAll(() => { + // Clean up from the base directory + const root = os.platform() === 'win32' ? 'C:\\' : '/tmp'; + const base = path.join(root, path.basename(path.resolve(noGitNexusDir, '..', '..', '..', '..', '..', '..'))); + fs.rmSync(base, { recursive: true, force: true }); + }); + + it('ignores PostToolUse when no .gitnexus directory exists', () => { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "x"' }, + tool_output: { exit_code: 0 }, + cwd: noGitNexusDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + + it('ignores PreToolUse when no .gitnexus directory exists', () => { + const result = runHook(hookPath, { + hook_event_name: 'PreToolUse', + tool_name: 'Grep', + tool_input: { pattern: 'somePattern' }, + cwd: noGitNexusDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).toBeNull(); + }); + }); +}); diff --git a/gitnexus/test/integration/ignore-and-skip-e2e.test.ts b/gitnexus/test/integration/ignore-and-skip-e2e.test.ts new file mode 100644 index 0000000000..03720f4b99 --- /dev/null +++ b/gitnexus/test/integration/ignore-and-skip-e2e.test.ts @@ -0,0 +1,152 @@ +import { describe, it, expect, beforeAll, afterAll } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import os from 'os'; +import { walkRepositoryPaths, readFileContents } from '../../src/core/ingestion/filesystem-walker.js'; +import { processParsing } from '../../src/core/ingestion/parsing-processor.js'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import { createSymbolTable } from '../../src/core/ingestion/symbol-table.js'; +import { createASTCache } from '../../src/core/ingestion/ast-cache.js'; +import { isLanguageAvailable } from '../../src/core/tree-sitter/parser-loader.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; + +// ============================================================================ +// E2E: .gitignore + .gitnexusignore + unsupported language skip +// ============================================================================ + +describe('ignore + language-skip E2E', () => { + let tmpDir: string; + + beforeAll(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-e2e-ignore-skip-')); + + // Create directory structure + await fs.mkdir(path.join(tmpDir, 'src'), { recursive: true }); + await fs.mkdir(path.join(tmpDir, 'data'), { recursive: true }); + await fs.mkdir(path.join(tmpDir, 'vendor'), { recursive: true }); + + // .gitignore — excludes data/ and *.log + await fs.writeFile(path.join(tmpDir, '.gitignore'), 'data/\n*.log\n'); + + // .gitnexusignore — excludes vendor/ + await fs.writeFile(path.join(tmpDir, '.gitnexusignore'), 'vendor/\n'); + + // Source files (should be indexed) + await fs.writeFile( + path.join(tmpDir, 'src', 'index.ts'), + "import { greet } from './greet';\n\nexport function main(): string {\n return greet();\n}\n", + ); + await fs.writeFile( + path.join(tmpDir, 'src', 'greet.ts'), + "export function greet(): string {\n return 'hello';\n}\n", + ); + + // Swift file — triggers language skip when grammar unavailable + await fs.writeFile( + path.join(tmpDir, 'src', 'App.swift'), + 'class App {\n func run() {\n print("running")\n }\n}\n', + ); + + // Files that should be excluded + await fs.writeFile(path.join(tmpDir, 'data', 'seed.json'), '{}'); + await fs.writeFile(path.join(tmpDir, 'vendor', 'lib.js'), 'var x = 1;\n'); + await fs.writeFile(path.join(tmpDir, 'debug.log'), 'debug log entry\n'); + }); + + afterAll(async () => { + try { + await fs.rm(tmpDir, { recursive: true, force: true }); + } catch { /* best-effort */ } + }); + + // ── File Discovery ────────────────────────────────────────────────── + + describe('file discovery (walkRepositoryPaths)', () => { + it('includes source files from src/', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + expect(paths).toContain('src/index.ts'); + expect(paths).toContain('src/greet.ts'); + }); + + it('includes .swift files (discovery does not filter by language)', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + // Swift file should be discovered — language skip happens at parse time + expect(paths).toContain('src/App.swift'); + }); + + it('excludes gitignored directories (data/)', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + expect(paths.every(p => !p.includes('data/'))).toBe(true); + }); + + it('excludes gitignored file patterns (*.log)', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + expect(paths.every(p => !p.endsWith('.log'))).toBe(true); + }); + + it('excludes gitnexusignored directories (vendor/)', async () => { + const files = await walkRepositoryPaths(tmpDir); + const paths = files.map(f => f.path.replace(/\\/g, '/')); + + expect(paths.every(p => !p.includes('vendor/'))).toBe(true); + }); + }); + + // ── Parsing ───────────────────────────────────────────────────────── + + describe('parsing (processParsing)', () => { + it('parses TypeScript files into graph nodes and skips Swift gracefully', async () => { + // Phase 1: discover files + const scannedFiles = await walkRepositoryPaths(tmpDir); + const relativePaths = scannedFiles.map(f => f.path); + + // Phase 2: read contents + const contentMap = await readFileContents(tmpDir, relativePaths); + const files = Array.from(contentMap.entries()).map(([p, content]) => ({ + path: p, + content, + })); + + // Phase 3: parse (sequential — no worker pool) + const graph = createKnowledgeGraph(); + const symbolTable = createSymbolTable(); + const astCache = createASTCache(); + + // Should NOT throw even if Swift grammar is unavailable + await processParsing(graph, files, symbolTable, astCache); + + // TypeScript files should produce Function nodes + const nodes = graph.nodes; + const functionNodes = nodes.filter(n => n.label === 'Function'); + const functionNames = functionNodes.map(n => n.properties.name); + + expect(functionNames).toContain('main'); + expect(functionNames).toContain('greet'); + + // Function nodes should reference the correct source files + const fnFilePaths = functionNodes.map(n => + (n.properties.filePath as string).replace(/\\/g, '/'), + ); + expect(fnFilePaths.some(p => p.includes('index.ts'))).toBe(true); + expect(fnFilePaths.some(p => p.includes('greet.ts'))).toBe(true); + + // Swift behavior depends on grammar availability + if (!isLanguageAvailable(SupportedLanguages.Swift)) { + // No Swift-sourced nodes should appear in the graph + const swiftNodes = nodes.filter(n => + (n.properties.filePath as string | undefined)?.endsWith('.swift'), + ); + expect(swiftNodes).toHaveLength(0); + } + // If Swift IS available, Swift nodes may appear — that's fine + }); + }); +}); diff --git a/gitnexus/test/integration/lbug-core-adapter.test.ts b/gitnexus/test/integration/lbug-core-adapter.test.ts new file mode 100644 index 0000000000..c93ea0d830 --- /dev/null +++ b/gitnexus/test/integration/lbug-core-adapter.test.ts @@ -0,0 +1,137 @@ +/** + * P0 Integration Tests: Core LadybugDB Adapter + * + * Tests: loadGraphToLbug CSV round-trip, createFTSIndex, getLbugStats. + * + * IMPORTANT: All core adapter tests share ONE coreHandle and ONE coreInitLbug + * call because the core adapter is a module-level singleton. Calling + * coreInitLbug with a different path closes the previous native DB handle + * and opens a new one — sharing a single handle avoids unnecessary churn. + */ +import { describe, it, expect } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import { withTestLbugDB } from '../helpers/test-indexed-db.js'; + +// ─── Core LadybugDB Adapter ───────────────────────────────────────────── + +withTestLbugDB('core-adapter', (handle) => { + describe('core adapter', () => { + it('loadGraphToLbug: loads a minimal graph and node counts match', async () => { + const { executeQuery: coreExecuteQuery } = await import('../../src/core/lbug/lbug-adapter.js'); + + // createMinimalTestGraph has 2 File, 2 Function, 1 Class, 1 Folder = 6 nodes + const fileRows = await coreExecuteQuery('MATCH (n:File) RETURN n.id AS id'); + expect(fileRows).toHaveLength(2); + + const funcRows = await coreExecuteQuery('MATCH (n:Function) RETURN n.id AS id'); + expect(funcRows).toHaveLength(2); + + const classRows = await coreExecuteQuery('MATCH (n:Class) RETURN n.id AS id'); + expect(classRows).toHaveLength(1); + + const folderRows = await coreExecuteQuery('MATCH (n:Folder) RETURN n.id AS id'); + expect(folderRows).toHaveLength(1); + }); + + it('createFTSIndex: creates FTS index on Function table without error', async () => { + const { createFTSIndex } = await import('../../src/core/lbug/lbug-adapter.js'); + + await expect( + createFTSIndex('Function', 'function_fts', ['name', 'content']), + ).resolves.toBeUndefined(); + }); + + it('getLbugStats: returns correct node and edge counts for seeded data', async () => { + const { getLbugStats } = await import('../../src/core/lbug/lbug-adapter.js'); + + const stats = await getLbugStats(); + + // createMinimalTestGraph: 6 nodes (2 File, 2 Function, 1 Class, 1 Folder) + expect(stats.nodes).toBe(6); + + // 4 relationships (2 CALLS, 2 CONTAINS) + expect(stats.edges).toBe(4); + }); + + describe('unhappy path', () => { + it('throws on malformed Cypher query', async () => { + const { executeQuery } = await import('../../src/core/lbug/lbug-adapter.js'); + + // Deliberately broken syntax: MATCH without a pattern clause + await expect(executeQuery('MATCH RETURN 1')).rejects.toThrow(); + }); + + it('returns empty results for query matching no nodes', async () => { + const { executeQuery } = await import('../../src/core/lbug/lbug-adapter.js'); + + // Valid Cypher, but the id will never exist in the seeded graph + const rows = await executeQuery( + "MATCH (n:Function) WHERE n.id = '__nonexistent_id__' RETURN n.id AS id", + ); + expect(rows).toHaveLength(0); + }); + + it('handles query with non-existent table/node label', async () => { + const { executeQuery } = await import('../../src/core/lbug/lbug-adapter.js'); + + // LadybugDB throws when the node table does not exist in the schema + await expect( + executeQuery('MATCH (n:GhostTable) RETURN n'), + ).rejects.toThrow(); + }); + }); + + describe('error handling', () => { + it('createFTSIndex handles already-existing index gracefully', async () => { + const { createFTSIndex } = await import('../../src/core/lbug/lbug-adapter.js'); + + // First call creates the index (may already exist from earlier test) + await createFTSIndex('Function', 'function_fts_dup', ['name', 'content']); + + // Second call with same params should NOT throw — createFTSIndex catches "already exists" + await expect( + createFTSIndex('Function', 'function_fts_dup', ['name', 'content']), + ).resolves.toBeUndefined(); + }); + + it('getLbugStats returns valid counts', async () => { + const { getLbugStats } = await import('../../src/core/lbug/lbug-adapter.js'); + + // getLbugStats NEVER throws — it has silent catch blocks per table + const stats = await getLbugStats(); + expect(typeof stats.nodes).toBe('number'); + expect(typeof stats.edges).toBe('number'); + expect(stats.nodes).toBeGreaterThanOrEqual(0); + expect(stats.edges).toBeGreaterThanOrEqual(0); + }); + + it('executeQuery with empty string rejects', async () => { + const { executeQuery } = await import('../../src/core/lbug/lbug-adapter.js'); + + // LadybugDB throws on empty query string + await expect(executeQuery('')).rejects.toThrow(); + }); + + it('deleteNodesForFile with non-existent path returns zero deleted', async () => { + const { deleteNodesForFile } = await import('../../src/core/lbug/lbug-adapter.js'); + + // deleteNodesForFile has per-query try/catch, returns {deletedNodes: 0} for missing paths + const result = await deleteNodesForFile('/absolutely/nonexistent/path/file.ts'); + expect(result).toEqual({ deletedNodes: 0 }); + }); + }); + }); +}, { + afterSetup: async (handle) => { + // Load a minimal graph via CSV round-trip (core adapter is already initialized by wrapper) + const { loadGraphToLbug } = await import('../../src/core/lbug/lbug-adapter.js'); + const { createMinimalTestGraph } = await import('../helpers/test-graph.js'); + + const graph = createMinimalTestGraph(); + const storagePath = path.join(handle.tmpHandle.dbPath, 'storage'); + await fs.mkdir(storagePath, { recursive: true }); + + await loadGraphToLbug(graph, '/test/repo', storagePath); + }, +}); diff --git a/gitnexus/test/integration/lbug-pool-stability.test.ts b/gitnexus/test/integration/lbug-pool-stability.test.ts new file mode 100644 index 0000000000..81b04af4bb --- /dev/null +++ b/gitnexus/test/integration/lbug-pool-stability.test.ts @@ -0,0 +1,160 @@ +/** + * Integration Tests: LadybugDB Connection Pool — Parallel Stability + * + * Tests concurrency fixes from PR #349: + * - Pre-warmed pool handles max parallel queries + * - Waiter queue drains under overload + * - Concurrent initLbug deduplication + * - stdout.write restoration after parallel operations + * - No connection leaks over sequential workloads + * - Atomic pool entry visibility (pool.set last) + * - Mixed query types at full concurrency + * + * Connection budget: LadybugDB's native mmap budget caps at ~56 + * simultaneous Connection objects per process. Tests that only need + * a ready pool share a single 'shared-repo' init (8 connections) to + * stay well under the limit. + */ +import { it, expect, afterAll } from 'vitest'; +import { + initLbug, + executeQuery, + executeParameterized, + closeLbug, + isLbugReady, +} from '../../src/mcp/core/lbug-adapter.js'; +import { withTestLbugDB } from '../helpers/test-indexed-db.js'; + +const SEED_DATA = [ + `CREATE (f:File {id: 'file:index.ts', name: 'index.ts', filePath: 'src/index.ts', content: ''})`, + `CREATE (fn:Function {id: 'func:main', name: 'main', filePath: 'src/index.ts', startLine: 1, endLine: 10, isExported: true, content: '', description: ''})`, + `CREATE (fn2:Function {id: 'func:helper', name: 'helper', filePath: 'src/utils.ts', startLine: 1, endLine: 5, isExported: true, content: '', description: ''})`, + `MATCH (a:Function), (b:Function) + WHERE a.id = 'func:main' AND b.id = 'func:helper' + CREATE (a)-[:CodeRelation {type: 'CALLS', confidence: 1.0, reason: 'direct', step: 0}]->(b)`, +]; + +// ─── Shared-pool tests: reuse one init across 5 tests (8 connections total) ── + +withTestLbugDB('pool-stability', (handle) => { + const REPO = 'shared-par'; + let inited = false; + + const ensurePool = async () => { + if (!inited) { + await initLbug(REPO, handle.dbPath); + inited = true; + } + }; + + afterAll(async () => { + try { await closeLbug(REPO); } catch { /* best-effort */ } + }); + + it('8 simultaneous queries complete without crashes', async () => { + await ensurePool(); + const queries = Array.from({ length: 8 }, () => + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name') + ); + const results = await Promise.all(queries); + expect(results).toHaveLength(8); + for (const rows of results) { + expect(rows.length).toBeGreaterThanOrEqual(2); + } + }); + + it('12 parallel queries overflow into waiter queue and all complete', async () => { + await ensurePool(); + const queries = Array.from({ length: 12 }, () => + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name') + ); + const results = await Promise.all(queries); + expect(results).toHaveLength(12); + for (const rows of results) { + expect(rows.length).toBeGreaterThanOrEqual(2); + } + }); + + it('process.stdout.write is functional after init and parallel queries', async () => { + await ensurePool(); + const queries = Array.from({ length: 8 }, () => + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name') + ); + await Promise.all(queries); + // stdout.write should be the real function, not the silenced no-op + expect(typeof process.stdout.write).toBe('function'); + }); + + it('50 sequential queries do not leak connections', async () => { + await ensurePool(); + for (let i = 0; i < 50; i++) { + await executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'); + } + // If connections leaked, these 8 parallel queries would exhaust the pool + const queries = Array.from({ length: 8 }, () => + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name') + ); + const results = await Promise.all(queries); + expect(results).toHaveLength(8); + }); + + it('mixed executeQuery + executeParameterized at full concurrency', async () => { + await ensurePool(); + const queries = [ + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'), + executeParameterized(REPO, 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', { name: 'main' }), + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'), + executeParameterized(REPO, 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', { name: 'helper' }), + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'), + executeParameterized(REPO, 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', { name: 'main' }), + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'), + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'), + ]; + const results = await Promise.all(queries); + expect(results).toHaveLength(8); + }); + + // ─── Regression tests for #308 / #314 / #347 ────────────────────────── + // The impact command's enrichment phase runs 3 concurrent queries via + // Promise.all (local-backend.ts:1415). Before PR #349's pool pre-warming, + // this triggered lazy createConnection → silenceStdout → SIGSEGV. + + it('3 concurrent queries via Promise.all (impact enrichment pattern, #308/#314/#347)', async () => { + await ensurePool(); + // Mirrors the exact Promise.all pattern from local-backend.ts:1415 + // that caused SIGSEGV in issues #308, #314, #347 before pool pre-warming. + const [r1, r2, r3] = await Promise.all([ + executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name LIMIT 5').catch(() => []), + executeQuery(REPO, 'MATCH (n:Function) RETURN n.id AS id LIMIT 5').catch(() => []), + executeQuery(REPO, 'MATCH ()-[r:CodeRelation]->() RETURN r.type AS type LIMIT 5').catch(() => []), + ]); + expect(r1.length).toBeGreaterThanOrEqual(1); + expect(r2.length).toBeGreaterThanOrEqual(1); + expect(r3.length).toBeGreaterThanOrEqual(1); + }); + + // ─── Fresh-state tests: need their own init ────────────────────────── + + it('concurrent initLbug calls for the same repoId deduplicate', async () => { + const promises = Array.from({ length: 6 }, () => + initLbug('dedup-repo', handle.dbPath) + ); + await Promise.all(promises); + expect(isLbugReady('dedup-repo')).toBe(true); + const rows = await executeQuery('dedup-repo', 'MATCH (n:Function) RETURN n.name AS name'); + expect(rows.length).toBeGreaterThanOrEqual(2); + await closeLbug('dedup-repo'); + }); + + it('pool entry is not visible until initLbug fully resolves', async () => { + const initPromise = initLbug('atomic-repo', handle.dbPath); + // Synchronously, pool should NOT be ready (pool.set is the last operation) + expect(isLbugReady('atomic-repo')).toBe(false); + await initPromise; + expect(isLbugReady('atomic-repo')).toBe(true); + await closeLbug('atomic-repo'); + }); +}, { + seed: SEED_DATA, + poolAdapter: true, +}); diff --git a/gitnexus/test/integration/lbug-pool.test.ts b/gitnexus/test/integration/lbug-pool.test.ts new file mode 100644 index 0000000000..30ad01b149 --- /dev/null +++ b/gitnexus/test/integration/lbug-pool.test.ts @@ -0,0 +1,187 @@ +/** + * P0 Integration Tests: LadybugDB Connection Pool + * + * Tests: initLbug, executeQuery, executeParameterized, closeLbug lifecycle + * Covers hardening fixes: parameterized queries, query timeout, + * waiter queue timeout, idle eviction guards, stdout silencing race + */ +import { describe, it, expect, afterEach } from 'vitest'; +import { + initLbug, + executeQuery, + executeParameterized, + closeLbug, + isLbugReady, +} from '../../src/mcp/core/lbug-adapter.js'; +import { withTestLbugDB } from '../helpers/test-indexed-db.js'; + +const POOL_SEED_DATA = [ + `CREATE (f:File {id: 'file:index.ts', name: 'index.ts', filePath: 'src/index.ts', content: ''})`, + `CREATE (fn:Function {id: 'func:main', name: 'main', filePath: 'src/index.ts', startLine: 1, endLine: 10, isExported: true, content: '', description: ''})`, + `CREATE (fn2:Function {id: 'func:helper', name: 'helper', filePath: 'src/utils.ts', startLine: 1, endLine: 5, isExported: true, content: '', description: ''})`, + `MATCH (a:Function), (b:Function) + WHERE a.id = 'func:main' AND b.id = 'func:helper' + CREATE (a)-[:CodeRelation {type: 'CALLS', confidence: 1.0, reason: 'direct', step: 0}]->(b)`, +]; + +// ─── Pool lifecycle tests — test the pool adapter API directly ─────── + +withTestLbugDB('lbug-pool', (handle) => { + afterEach(async () => { + try { await closeLbug('test-repo'); } catch { /* best-effort */ } + try { await closeLbug('repo1'); } catch { /* best-effort */ } + try { await closeLbug('repo2'); } catch { /* best-effort */ } + try { await closeLbug(''); } catch { /* best-effort */ } + }); + + // ─── Lifecycle: init → query → close ───────────────────────────────── + + describe('pool lifecycle', () => { + it('initLbug + executeQuery + closeLbug', async () => { + await initLbug('test-repo', handle.dbPath); + expect(isLbugReady('test-repo')).toBe(true); + + const rows = await executeQuery('test-repo', 'MATCH (n:Function) RETURN n.name AS name'); + expect(rows.length).toBeGreaterThanOrEqual(2); + const names = rows.map((r: any) => r.name); + expect(names).toContain('main'); + expect(names).toContain('helper'); + + await closeLbug('test-repo'); + expect(isLbugReady('test-repo')).toBe(false); + }); + + it('initLbug reuses existing pool entry', async () => { + await initLbug('test-repo', handle.dbPath); + await initLbug('test-repo', handle.dbPath); // second call should be no-op + expect(isLbugReady('test-repo')).toBe(true); + }); + + it('closeLbug is idempotent', async () => { + await initLbug('test-repo', handle.dbPath); + await closeLbug('test-repo'); + await closeLbug('test-repo'); // second close should not throw + expect(isLbugReady('test-repo')).toBe(false); + }); + + it('closeLbug with no args closes all repos', async () => { + await initLbug('repo1', handle.dbPath); + await initLbug('repo2', handle.dbPath); + expect(isLbugReady('repo1')).toBe(true); + expect(isLbugReady('repo2')).toBe(true); + + await closeLbug(); + expect(isLbugReady('repo1')).toBe(false); + expect(isLbugReady('repo2')).toBe(false); + }); + }); + + // ─── Parameterized queries ─────────────────────────────────────────── + + describe('executeParameterized', () => { + it('works with parameterized query', async () => { + await initLbug('test-repo', handle.dbPath); + const rows = await executeParameterized( + 'test-repo', + 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', + { name: 'main' }, + ); + expect(rows).toHaveLength(1); + expect(rows[0].name).toBe('main'); + }); + + it('injection attempt is harmless with parameterized query', async () => { + await initLbug('test-repo', handle.dbPath); + const rows = await executeParameterized( + 'test-repo', + 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', + { name: "' OR 1=1 --" }, // SQL/Cypher injection attempt + ); + // Should return 0 rows, not all rows + expect(rows).toHaveLength(0); + }); + }); + + // ─── Error handling ────────────────────────────────────────────────── + + describe('error handling', () => { + it('throws when querying uninitialized repo', async () => { + await expect(executeQuery('nonexistent-repo', 'MATCH (n) RETURN n')) + .rejects.toThrow(/not initialized/); + }); + + it('throws when db path does not exist', async () => { + await expect(initLbug('bad-repo', '/nonexistent/path/lbug')) + .rejects.toThrow(); + }); + + it('read-only mode: write query throws', async () => { + await initLbug('test-repo', handle.dbPath); + await expect(executeQuery('test-repo', "CREATE (n:Function {id: 'new', name: 'new', filePath: '', startLine: 0, endLine: 0, isExported: false, content: '', description: ''})")) + .rejects.toThrow(); + }); + }); + + // ─── Relationship queries ──────────────────────────────────────────── + + describe('relationship queries', () => { + it('can query relationships', async () => { + await initLbug('test-repo', handle.dbPath); + const rows = await executeQuery( + 'test-repo', + `MATCH (a:Function)-[r:CodeRelation {type: 'CALLS'}]->(b:Function) RETURN a.name AS caller, b.name AS callee`, + ); + expect(rows.length).toBeGreaterThanOrEqual(1); + const row = rows.find((r: any) => r.caller === 'main'); + expect(row).toBeDefined(); + expect(row.callee).toBe('helper'); + }); + }); + + // ─── Unhappy paths ────────────────────────────────────────────────── + + describe('unhappy paths', () => { + it('executeParameterized throws when repo is not initialized', async () => { + await expect(executeParameterized('ghost-repo', 'MATCH (n) RETURN n', {})) + .rejects.toThrow(/not initialized/); + }); + + it('executeQuery rejects invalid Cypher syntax', async () => { + await initLbug('test-repo', handle.dbPath); + await expect(executeQuery('test-repo', 'THIS IS NOT CYPHER')) + .rejects.toThrow(); + }); + + it('executeParameterized rejects when referenced parameter is missing', async () => { + await initLbug('test-repo', handle.dbPath); + await expect(executeParameterized( + 'test-repo', + 'MATCH (n:Function) WHERE n.name = $name RETURN n', + { wrong_param: 'main' }, + )).rejects.toThrow(); + }); + + it('closeLbug with unknown repoId does not throw', async () => { + await expect(closeLbug('never-existed-repo')).resolves.toBeUndefined(); + }); + + it('isLbugReady returns false for unknown repoId', () => { + expect(isLbugReady('never-existed-repo')).toBe(false); + }); + + it('initLbug with empty string repoId stores entry under empty key', async () => { + await initLbug('', handle.dbPath); + expect(isLbugReady('')).toBe(true); + await closeLbug(''); + expect(isLbugReady('')).toBe(false); + }); + + it('executeQuery with empty query string rejects', async () => { + await initLbug('test-repo', handle.dbPath); + await expect(executeQuery('test-repo', '')).rejects.toThrow(); + }); + }); +}, { + seed: POOL_SEED_DATA, + poolAdapter: true, +}); diff --git a/gitnexus/test/integration/local-backend-calltool.test.ts b/gitnexus/test/integration/local-backend-calltool.test.ts new file mode 100644 index 0000000000..dd89923877 --- /dev/null +++ b/gitnexus/test/integration/local-backend-calltool.test.ts @@ -0,0 +1,272 @@ +/** + * P0 Integration Tests: Local Backend — callTool dispatch + * + * Tests the full LocalBackend.callTool() dispatch with a real LadybugDB + * instance, verifying cypher, context, impact, and query tools work + * end-to-end against seeded graph data with FTS indexes. + */ +import { describe, it, expect, beforeAll, vi } from 'vitest'; +import { LocalBackend } from '../../src/mcp/local/local-backend.js'; +import { listRegisteredRepos } from '../../src/storage/repo-manager.js'; +import { withTestLbugDB } from '../helpers/test-indexed-db.js'; +import { LOCAL_BACKEND_SEED_DATA, LOCAL_BACKEND_FTS_INDEXES } from '../fixtures/local-backend-seed.js'; + +vi.mock('../../src/storage/repo-manager.js', () => ({ + listRegisteredRepos: vi.fn().mockResolvedValue([]), + cleanupOldKuzuFiles: vi.fn().mockResolvedValue({ found: false, needsReindex: false }), +})); + +// ─── Block 2: callTool dispatch tests ──────────────────────────────── + +withTestLbugDB('local-backend-calltool', (handle) => { + + describe('callTool dispatch with real DB', () => { + let backend: LocalBackend; + + beforeAll(async () => { + // backend is created in afterSetup and attached to the handle + const ext = handle as typeof handle & { _backend?: LocalBackend }; + if (!ext._backend) { + throw new Error('LocalBackend not initialized — afterSetup did not attach _backend to handle'); + } + backend = ext._backend; + }); + + it('cypher tool returns function names', async () => { + const result = await backend.callTool('cypher', { + query: 'MATCH (n:Function) RETURN n.name AS name ORDER BY n.name', + }); + // cypher tool wraps results as markdown + expect(result).toHaveProperty('markdown'); + expect(result).toHaveProperty('row_count'); + expect(result.row_count).toBeGreaterThanOrEqual(3); + expect(result.markdown).toContain('login'); + expect(result.markdown).toContain('validate'); + expect(result.markdown).toContain('hash'); + }); + + it('cypher tool blocks write queries', async () => { + const result = await backend.callTool('cypher', { + query: "CREATE (n:Function {id: 'x', name: 'x', filePath: '', startLine: 0, endLine: 0, isExported: false, content: '', description: ''})", + }); + expect(result).toHaveProperty('error'); + expect(result.error).toMatch(/write operations/i); + }); + + it('context tool returns symbol info with callers and callees', async () => { + const result = await backend.callTool('context', { name: 'login' }); + expect(result).not.toHaveProperty('error'); + expect(result.status).toBe('found'); + // Should have the symbol identity + expect(result.symbol).toBeDefined(); + expect(result.symbol.name).toBe('login'); + expect(result.symbol.filePath).toBe('src/auth.ts'); + // login calls validate and hash — should appear in outgoing.calls + expect(result.outgoing).toBeDefined(); + expect(result.outgoing.calls).toBeDefined(); + expect(result.outgoing.calls.length).toBeGreaterThanOrEqual(2); + const calleeNames = result.outgoing.calls.map((c: any) => c.name); + expect(calleeNames).toContain('validate'); + expect(calleeNames).toContain('hash'); + }); + + it('impact tool returns upstream dependents', async () => { + const result = await backend.callTool('impact', { + target: 'validate', + direction: 'upstream', + }); + expect(result).not.toHaveProperty('error'); + // validate is called by login, so login should appear at depth 1 + expect(result.impactedCount).toBeGreaterThanOrEqual(1); + expect(result.byDepth).toBeDefined(); + const directDeps = result.byDepth[1] || result.byDepth['1'] || []; + expect(directDeps.length).toBeGreaterThanOrEqual(1); + const depNames = directDeps.map((d: any) => d.name); + expect(depNames).toContain('login'); + }); + + it('query tool returns results for keyword search', async () => { + const result = await backend.callTool('query', { query: 'login' }); + expect(result).not.toHaveProperty('error'); + // Should have some combination of processes, process_symbols, or definitions + expect(result).toHaveProperty('processes'); + expect(result).toHaveProperty('definitions'); + // The search should find something (FTS or graph-based) + const totalResults = + (result.processes?.length || 0) + + (result.process_symbols?.length || 0) + + (result.definitions?.length || 0); + expect(totalResults).toBeGreaterThanOrEqual(1); + }); + + it('unknown tool throws', async () => { + await expect( + backend.callTool('nonexistent_tool', {}), + ).rejects.toThrow(/unknown tool/i); + }); + }); + + describe('impact tool relationTypes filtering', () => { + let backend: LocalBackend; + + beforeAll(async () => { + const ext = handle as typeof handle & { _backend?: LocalBackend }; + if (!ext._backend) { + throw new Error('LocalBackend not initialized — afterSetup did not attach _backend to handle'); + } + backend = ext._backend; + }); + + it('filters by HAS_METHOD only', async () => { + const result = await backend.callTool('impact', { + target: 'AuthService', + direction: 'downstream', + relationTypes: ['HAS_METHOD'], + }); + expect(result).not.toHaveProperty('error'); + expect(result.impactedCount).toBeGreaterThanOrEqual(1); + const d1 = result.byDepth[1] || result.byDepth['1'] || []; + const names = d1.map((d: any) => d.name); + expect(names).toContain('authenticate'); + // Should NOT include CALLS-reachable symbols like validate/hash + expect(names).not.toContain('validate'); + expect(names).not.toContain('hash'); + }); + + it('filters by OVERRIDES only', async () => { + const result = await backend.callTool('impact', { + target: 'authenticate', + direction: 'downstream', + relationTypes: ['OVERRIDES'], + }); + expect(result).not.toHaveProperty('error'); + // AuthService.authenticate overrides BaseService.authenticate + expect(result.impactedCount).toBeGreaterThanOrEqual(1); + const d1 = result.byDepth[1] || result.byDepth['1'] || []; + const names = d1.map((d: any) => d.name); + expect(names).toContain('authenticate'); + }); + + it('does not return HAS_METHOD results when filtering by CALLS only', async () => { + const result = await backend.callTool('impact', { + target: 'AuthService', + direction: 'downstream', + relationTypes: ['CALLS'], + }); + expect(result).not.toHaveProperty('error'); + // AuthService has no outgoing CALLS edges, only HAS_METHOD + expect(result.impactedCount).toBe(0); + }); + }); + + describe('tool parameter edge cases', () => { + let backend: LocalBackend; + + beforeAll(async () => { + const ext = handle as typeof handle & { _backend?: LocalBackend }; + if (!ext._backend) { + throw new Error('LocalBackend not initialized — afterSetup did not attach _backend to handle'); + } + backend = ext._backend; + }); + + it('context tool returns error for nonexistent symbol', async () => { + const result = await backend.callTool('context', { name: 'nonexistent_xyz_symbol_999' }); + expect(result).toHaveProperty('error'); + expect(result.error).toMatch(/not found/i); + }); + + it('query tool returns error for empty query', async () => { + const result = await backend.callTool('query', { query: '' }); + expect(result).toHaveProperty('error'); + expect(result.error).toMatch(/required/i); + }); + + it('query tool returns error for missing query param', async () => { + const result = await backend.callTool('query', {}); + expect(result).toHaveProperty('error'); + }); + + it('cypher tool returns error for invalid Cypher syntax', async () => { + const result = await backend.callTool('cypher', { query: 'THIS IS NOT VALID CYPHER AT ALL' }); + expect(result).toHaveProperty('error'); + }); + + it('context tool returns error when no name or uid provided', async () => { + const result = await backend.callTool('context', {}); + expect(result).toHaveProperty('error'); + expect(result.error).toMatch(/required/i); + }); + + // ─── impact error handling tests (#321) ─────────────────────────── + // Verify that impact() returns structured JSON instead of crashing + + it('impact tool returns structured error for unknown symbol', async () => { + const result = await backend.callTool('impact', { + target: 'nonexistent_symbol_xyz_999', + direction: 'upstream', + }); + // Must return structured JSON, not throw + expect(result).toBeDefined(); + // Should have either an error field (not found) or impactedCount 0 + // Either outcome is valid — the key is it doesn't crash + if (result.error) { + expect(typeof result.error).toBe('string'); + } else { + expect(result.impactedCount).toBe(0); + } + }); + + it('impact error response has consistent target shape', async () => { + const result = await backend.callTool('impact', { + target: 'nonexistent_symbol_xyz_999', + direction: 'downstream', + }); + // When an error is returned, target must be an object (not raw string) + // so downstream API consumers can safely access result.target.name + if (result.error && result.target !== undefined) { + expect(typeof result.target).toBe('object'); + expect(result.target).not.toBeNull(); + } + }); + + it('impact partial results: traversalComplete flag when depth fails', async () => { + // Even if traversal fails at some depth, partial results should be returned + // and partial:true should only be set when some results were collected + const result = await backend.callTool('impact', { + target: 'validate', + direction: 'upstream', + maxDepth: 10, // Large depth to trigger multi-level traversal + }); + // Should succeed (validate exists in seed data) + expect(result).not.toHaveProperty('error'); + if (result.partial) { + // If partial, must still have some results + expect(result.impactedCount).toBeGreaterThan(0); + } + }); + }); + +}, { + seed: LOCAL_BACKEND_SEED_DATA, + ftsIndexes: LOCAL_BACKEND_FTS_INDEXES, + poolAdapter: true, + afterSetup: async (handle) => { + // Configure listRegisteredRepos mock with handle values + vi.mocked(listRegisteredRepos).mockResolvedValue([ + { + name: 'test-repo', + path: '/test/repo', + storagePath: handle.tmpHandle.dbPath, + indexedAt: new Date().toISOString(), + lastCommit: 'abc123', + stats: { files: 2, nodes: 3, communities: 1, processes: 1 }, + }, + ]); + + const backend = new LocalBackend(); + await backend.init(); + // Stash backend on handle so tests can access it + (handle as any)._backend = backend; + }, +}); diff --git a/gitnexus/test/integration/local-backend.test.ts b/gitnexus/test/integration/local-backend.test.ts new file mode 100644 index 0000000000..23c233e63b --- /dev/null +++ b/gitnexus/test/integration/local-backend.test.ts @@ -0,0 +1,257 @@ +/** + * P0 Integration Tests: Local Backend + * + * Tests tool implementations via direct LadybugDB queries. + * The full LocalBackend.callTool() requires a global registry, + * so here we test the security-critical behaviors directly: + * - Write-operation blocking in cypher + * - Query execution via the pool + * - Parameterized queries preventing injection + * - Read-only enforcement + * + * Covers hardening fixes: #1 (parameterized queries), #2 (write blocking), + * #3 (path traversal), #4 (relation allowlist), #25 (regex lastIndex), + * #26 (rename first-occurrence-only) + */ +import { describe, it, expect } from 'vitest'; +import { + CYPHER_WRITE_RE, + executeQuery, + executeParameterized, + isWriteQuery, +} from '../../src/mcp/core/lbug-adapter.js'; +import { VALID_RELATION_TYPES } from '../../src/mcp/local/local-backend.js'; +import { withTestLbugDB } from '../helpers/test-indexed-db.js'; +import { LOCAL_BACKEND_SEED_DATA } from '../fixtures/local-backend-seed.js'; + +// ─── Block 1: Pool adapter tests ───────────────────────────────────── + +withTestLbugDB('local-backend', (handle) => { + + // ─── Cypher write blocking ─────────────────────────────────────────── + + describe('cypher write blocking', () => { + const allWriteKeywords = ['CREATE', 'DELETE', 'SET', 'MERGE', 'REMOVE', 'DROP', 'ALTER', 'COPY', 'DETACH']; + + for (const keyword of allWriteKeywords) { + it(`blocks ${keyword} query`, () => { + const blocked = isWriteQuery(`MATCH (n) ${keyword} n.name = "x"`); + expect(blocked).toBe(true); + }); + } + + it('allows valid read queries through the pool', async () => { + const rows = await executeQuery(handle.repoId, 'MATCH (n:Function) RETURN n.name AS name ORDER BY n.name'); + expect(rows.length).toBeGreaterThanOrEqual(3); + }); + }); + + // ─── Parameterized queries ─────────────────────────────────────────── + + describe('parameterized queries', () => { + it('finds exact match with parameter', async () => { + const rows = await executeParameterized( + handle.repoId, + 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name, n.filePath AS filePath', + { name: 'login' }, + ); + expect(rows).toHaveLength(1); + expect(rows[0].name).toBe('login'); + expect(rows[0].filePath).toBe('src/auth.ts'); + }); + + it('injection is harmless', async () => { + const rows = await executeParameterized( + handle.repoId, + 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', + { name: "login' OR '1'='1" }, + ); + expect(rows).toHaveLength(0); + }); + }); + + // ─── Relation type filtering ───────────────────────────────────────── + + describe('relation type filtering', () => { + it('only allows valid relation types in queries', () => { + const validTypes = ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'OVERRIDES', 'ACCESSES']; + const invalidTypes = ['CONTAINS', 'STEP_IN_PROCESS', 'MEMBER_OF', 'DROP_TABLE']; + + for (const t of validTypes) { + expect(VALID_RELATION_TYPES.has(t)).toBe(true); + } + for (const t of invalidTypes) { + expect(VALID_RELATION_TYPES.has(t)).toBe(false); + } + }); + + it('can query relationships with valid types', async () => { + const rows = await executeQuery( + handle.repoId, + `MATCH (a:Function)-[r:CodeRelation {type: 'CALLS'}]->(b:Function) RETURN a.name AS caller, b.name AS callee ORDER BY b.name`, + ); + expect(rows.length).toBeGreaterThanOrEqual(2); + }); + }); + + // ─── Process queries ───────────────────────────────────────────────── + + describe('process queries', () => { + it('can find processes', async () => { + const rows = await executeQuery(handle.repoId, 'MATCH (p:Process) RETURN p.heuristicLabel AS label, p.stepCount AS steps'); + expect(rows.length).toBeGreaterThanOrEqual(1); + expect(rows[0].label).toBe('User Login'); + }); + + it('can trace process steps', async () => { + const rows = await executeQuery( + handle.repoId, + `MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) + WHERE p.id = 'proc:login-flow' + RETURN s.name AS symbol, r.step AS step + ORDER BY r.step`, + ); + expect(rows).toHaveLength(2); + expect(rows[0].symbol).toBe('login'); + expect(rows[0].step).toBe(1); + expect(rows[1].symbol).toBe('validate'); + expect(rows[1].step).toBe(2); + }); + }); + + // ─── Community queries ─────────────────────────────────────────────── + + describe('community queries', () => { + it('can find communities', async () => { + const rows = await executeQuery(handle.repoId, 'MATCH (c:Community) RETURN c.heuristicLabel AS label'); + expect(rows.length).toBeGreaterThanOrEqual(1); + expect(rows[0].label).toBe('Authentication'); + }); + + it('can find community members', async () => { + const rows = await executeQuery( + handle.repoId, + `MATCH (f)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) + WHERE c.heuristicLabel = 'Authentication' + RETURN f.name AS name`, + ); + expect(rows.length).toBeGreaterThanOrEqual(1); + expect(rows[0].name).toBe('login'); + }); + }); + + // ─── Read-only enforcement ─────────────────────────────────────────── + + describe('read-only database', () => { + it('rejects write operations at DB level', async () => { + await expect( + executeQuery(handle.repoId, `CREATE (n:Function {id: 'new', name: 'new', filePath: '', startLine: 0, endLine: 0, isExported: false, content: '', description: ''})`) + ).rejects.toThrow(); + }); + }); + + // ─── Regex lastIndex hardening (#25) ───────────────────────────────── + + describe('regex lastIndex (hardening #25)', () => { + it('CYPHER_WRITE_RE is non-global (no sticky lastIndex)', () => { + expect(CYPHER_WRITE_RE.global).toBe(false); + expect(CYPHER_WRITE_RE.sticky).toBe(false); + }); + + it('works correctly across multiple consecutive calls', () => { + // If the regex were global, lastIndex could cause false results + const results = [ + isWriteQuery('CREATE (n)'), // true + isWriteQuery('MATCH (n) RETURN n'), // false + isWriteQuery('DELETE n'), // true + isWriteQuery('MATCH (n) RETURN n'), // false + isWriteQuery('SET n.x = 1'), // true + ]; + expect(results).toEqual([true, false, true, false, true]); + }); + }); + + // ─── Content queries (include_content equivalent) ──────────────────── + + describe('content queries', () => { + it('can retrieve symbol content', async () => { + const rows = await executeQuery( + handle.repoId, + `MATCH (n:Function) WHERE n.name = 'login' RETURN n.content AS content`, + ); + expect(rows).toHaveLength(1); + expect(rows[0].content).toContain('function login'); + }); + }); + + // ─── Write blocking edge cases ────────────────────────────────────── + + describe('write blocking edge cases', () => { + it('blocks lowercase write keywords (case-insensitive)', () => { + expect(isWriteQuery('create (n:Function {id: "x"})')).toBe(true); + expect(isWriteQuery('delete n')).toBe(true); + expect(isWriteQuery('set n.name = "x"')).toBe(true); + }); + + it('blocks write keyword in CREATED-like words (regex is keyword-boundary unaware)', () => { + // CYPHER_WRITE_RE uses \b word boundaries — "CREATED" does NOT match "CREATE" + const result = isWriteQuery("MATCH (n) WHERE n.name = 'CREATED' RETURN n"); + // The regex uses word boundaries so substring "CREATE" inside "CREATED" is NOT matched + expect(result).toBe(false); + }); + + it('blocks multi-line queries with write keywords', () => { + expect(isWriteQuery('MATCH (n)\nDELETE n')).toBe(true); + }); + + it('returns false for empty string', () => { + expect(isWriteQuery('')).toBe(false); + }); + + it('returns false for whitespace-only query', () => { + expect(isWriteQuery(' ')).toBe(false); + }); + }); + + // ─── Query error handling via pool ────────────────────────────────── + + describe('query error handling via pool', () => { + it('returns empty rows for unknown node label', async () => { + // LadybugDB throws a Binder exception for unknown node labels + await expect( + executeQuery(handle.repoId, 'MATCH (n:NonExistentTable) RETURN n.name AS name') + ).rejects.toThrow(); + }); + + it('rejects syntactically invalid Cypher', async () => { + await expect(executeQuery(handle.repoId, 'NOT VALID CYPHER AT ALL')) + .rejects.toThrow(); + }); + }); + + // ─── Parameterized query edge cases ───────────────────────────────── + + describe('parameterized query edge cases', () => { + it('succeeds with empty params when query has no parameters', async () => { + const rows = await executeParameterized( + handle.repoId, + 'MATCH (n:Function) RETURN n.name AS name LIMIT 1', + {}, + ); + expect(rows.length).toBeGreaterThanOrEqual(0); + }); + + it('returns empty rows when param value is null', async () => { + const rows = await executeParameterized( + handle.repoId, + 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', + { name: null as any }, + ); + expect(rows).toHaveLength(0); + }); + }); + +}, { + seed: LOCAL_BACKEND_SEED_DATA, + poolAdapter: true, +}); diff --git a/gitnexus/test/integration/parsing.test.ts b/gitnexus/test/integration/parsing.test.ts new file mode 100644 index 0000000000..e918e181f5 --- /dev/null +++ b/gitnexus/test/integration/parsing.test.ts @@ -0,0 +1,758 @@ +/** + * P1 Integration Tests: Tree-sitter Parsing + * + * Tests parsing of sample files via tree-sitter. + * Covers hardening fixes: Swift init constructor (#18), + * PHP export detection (#20), symbol ID with startLine (#19), + * definition node range (#22). + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import { isNodeExported } from '../../src/core/ingestion/parsing-processor.js'; +import { loadParser, loadLanguage } from '../../src/core/tree-sitter/parser-loader.js'; +import { getLanguageFromFilename } from '../../src/core/ingestion/utils.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; + +const FIXTURES_DIR = path.join(process.cwd(), 'test', 'fixtures', 'sample-code'); + +// We test isNodeExported directly since it's a pure function +// that only needs a mock AST node, name, and language string. + +/** + * Minimal mock of a tree-sitter AST node. + */ +function mockNode(type: string, text: string = '', parent?: any, children?: any[], fields?: Record<string, any>): any { + const node: any = { + type, + text, + parent: parent || null, + childCount: children?.length ?? 0, + child: (i: number) => children?.[i] ?? null, + childForFieldName: (name: string) => fields?.[name] ?? null, + }; + // Set parent references on children + if (children) { + for (const child of children) { + child.parent = node; + } + } + return node; +} + +// ─── isNodeExported per-language ───────────────────────────────────── + +describe('parsing', () => { + describe('isNodeExported', () => { + // TypeScript/JavaScript + describe('typescript', () => { + it('returns true when ancestor is export_statement', () => { + const exportStmt = mockNode('export_statement', 'export function foo() {}'); + const fnDecl = mockNode('function_declaration', 'function foo() {}', exportStmt); + const nameNode = mockNode('identifier', 'foo', fnDecl); + expect(isNodeExported(nameNode, 'foo', 'typescript')).toBe(true); + }); + + it('returns false for non-exported function', () => { + const fnDecl = mockNode('function_declaration', 'function foo() {}'); + const nameNode = mockNode('identifier', 'foo', fnDecl); + expect(isNodeExported(nameNode, 'foo', 'typescript')).toBe(false); + }); + + it('returns true when text starts with "export "', () => { + const parent = mockNode('lexical_declaration', 'export const foo = 1'); + const nameNode = mockNode('identifier', 'foo', parent); + expect(isNodeExported(nameNode, 'foo', 'typescript')).toBe(true); + }); + }); + + // Python + describe('python', () => { + it('public function (no underscore prefix)', () => { + const node = mockNode('identifier', 'public_function'); + expect(isNodeExported(node, 'public_function', 'python')).toBe(true); + }); + + it('private function (underscore prefix)', () => { + const node = mockNode('identifier', '_private_helper'); + expect(isNodeExported(node, '_private_helper', 'python')).toBe(false); + }); + + it('dunder method is private', () => { + const node = mockNode('identifier', '__init__'); + expect(isNodeExported(node, '__init__', 'python')).toBe(false); + }); + }); + + // Go + describe('go', () => { + it('uppercase first letter is exported', () => { + const node = mockNode('identifier', 'ExportedFunction'); + expect(isNodeExported(node, 'ExportedFunction', 'go')).toBe(true); + }); + + it('lowercase first letter is unexported', () => { + const node = mockNode('identifier', 'unexportedFunction'); + expect(isNodeExported(node, 'unexportedFunction', 'go')).toBe(false); + }); + + it('empty name is not exported', () => { + const node = mockNode('identifier', ''); + expect(isNodeExported(node, '', 'go')).toBe(false); + }); + }); + + // Rust + describe('rust', () => { + it('pub function is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub'); + const nameNode = mockNode('identifier', 'foo'); + // visibility_modifier is a sibling of the name inside function_item + const fnDecl = mockNode('function_item', 'pub fn foo() {}', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'foo', 'rust')).toBe(true); + }); + + it('non-pub function is not exported', () => { + const nameNode = mockNode('identifier', 'foo'); + const fnDecl = mockNode('function_item', 'fn foo() {}', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'foo', 'rust')).toBe(false); + }); + }); + + // PHP (hardening fix #20) + describe('php', () => { + it('top-level function is exported (globally accessible)', () => { + // PHP: top-level functions fall through all checks and return true + const program = mockNode('program', '<?php function topLevel() {}'); + const fnDecl = mockNode('function_definition', 'function topLevel() {}', program); + const nameNode = mockNode('name', 'topLevel', fnDecl); + expect(isNodeExported(nameNode, 'topLevel', 'php')).toBe(true); + }); + + it('class declaration is exported', () => { + const classDecl = mockNode('class_declaration', 'class Foo {}'); + const nameNode = mockNode('name', 'Foo', classDecl); + expect(isNodeExported(nameNode, 'Foo', 'php')).toBe(true); + }); + + it('public method has visibility_modifier = public', () => { + const visMod = mockNode('visibility_modifier', 'public'); + const nameNode = mockNode('name', 'addUser', visMod); + expect(isNodeExported(nameNode, 'addUser', 'php')).toBe(true); + }); + + it('private method has visibility_modifier = private', () => { + const visMod = mockNode('visibility_modifier', 'private'); + const nameNode = mockNode('name', 'validate', visMod); + expect(isNodeExported(nameNode, 'validate', 'php')).toBe(false); + }); + }); + + // Swift + describe('swift', () => { + it('public function is exported', () => { + const visMod = mockNode('modifiers', 'public'); + const nameNode = mockNode('identifier', 'getCount', visMod); + expect(isNodeExported(nameNode, 'getCount', 'swift')).toBe(true); + }); + + it('open function is exported', () => { + const visMod = mockNode('modifiers', 'open'); + const nameNode = mockNode('identifier', 'doStuff', visMod); + expect(isNodeExported(nameNode, 'doStuff', 'swift')).toBe(true); + }); + + it('non-public function is not exported', () => { + const fnDecl = mockNode('function_declaration', 'func helper() {}'); + const nameNode = mockNode('identifier', 'helper', fnDecl); + expect(isNodeExported(nameNode, 'helper', 'swift')).toBe(false); + }); + }); + + // C/C++ + describe('c/cpp', () => { + it('C functions without static are exported (external linkage)', () => { + const nameNode = mockNode('identifier', 'add'); + const fnDef = mockNode('function_definition', 'int add(int a, int b) {}', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'add', 'c')).toBe(true); + }); + + it('C++ functions without static are exported', () => { + const nameNode = mockNode('identifier', 'helperFunction'); + const fnDef = mockNode('function_definition', 'void helperFunction() {}', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'helperFunction', 'cpp')).toBe(true); + }); + + it('static C function is not exported', () => { + const nameNode = mockNode('identifier', 'internalHelper'); + const staticSpec = mockNode('storage_class_specifier', 'static'); + const fnDef = mockNode('function_definition', 'static void internalHelper() {}', undefined, [staticSpec, nameNode]); + expect(isNodeExported(nameNode, 'internalHelper', 'c')).toBe(false); + }); + }); + + // C# + describe('csharp', () => { + it('public modifier means exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'Add'); + // modifier is a sibling of nameNode inside method_declaration + const methodDecl = mockNode('method_declaration', 'public int Add() {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'Add', 'csharp')).toBe(true); + }); + + it('no public modifier means not exported', () => { + const nameNode = mockNode('identifier', 'Helper'); + const classDecl = mockNode('class_declaration', 'class Helper {}', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'Helper', 'csharp')).toBe(false); + }); + }); + + // Java + describe('java', () => { + it('public method is exported', () => { + const modifiers = mockNode('modifiers', 'public'); + const nameNode = mockNode('identifier', 'getUser'); + const methodDecl = mockNode('method_declaration', 'public User getUser() {}', undefined, [modifiers, nameNode]); + expect(isNodeExported(nameNode, 'getUser', 'java')).toBe(true); + }); + + it('public class method via text check is exported', () => { + const nameNode = mockNode('identifier', 'doGet'); + const methodDecl = mockNode('method_declaration', 'public void doGet() {}', undefined, [nameNode]); + // text starts with 'public' so it should be detected + expect(isNodeExported(nameNode, 'doGet', 'java')).toBe(true); + }); + + it('private method is not exported', () => { + const modifiers = mockNode('modifiers', 'private'); + const nameNode = mockNode('identifier', 'helper'); + const methodDecl = mockNode('method_declaration', 'private void helper() {}', undefined, [modifiers, nameNode]); + expect(isNodeExported(nameNode, 'helper', 'java')).toBe(false); + }); + + it('package-private (no modifier) is not exported', () => { + const nameNode = mockNode('identifier', 'internal'); + const methodDecl = mockNode('method_declaration', 'void internal() {}', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'internal', 'java')).toBe(false); + }); + }); + + // Kotlin + describe('kotlin', () => { + it('function without visibility modifier is public by default', () => { + const nameNode = mockNode('identifier', 'greet'); + const fnDecl = mockNode('function_declaration', 'fun greet() {}', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'greet', 'kotlin')).toBe(true); + }); + + it('public function is exported', () => { + const visMod = mockNode('visibility_modifier', 'public'); + const modifiers = mockNode('modifiers', 'public', undefined, [visMod]); + const nameNode = mockNode('identifier', 'greet'); + const fnDecl = mockNode('function_declaration', 'public fun greet() {}', undefined, [modifiers, nameNode]); + expect(isNodeExported(nameNode, 'greet', 'kotlin')).toBe(true); + }); + + it('private function is not exported', () => { + const visMod = mockNode('visibility_modifier', 'private'); + const modifiers = mockNode('modifiers', 'private', undefined, [visMod]); + const nameNode = mockNode('identifier', 'secret'); + const fnDecl = mockNode('function_declaration', 'private fun secret() {}', undefined, [modifiers, nameNode]); + expect(isNodeExported(nameNode, 'secret', 'kotlin')).toBe(false); + }); + + it('internal function is not exported', () => { + const visMod = mockNode('visibility_modifier', 'internal'); + const modifiers = mockNode('modifiers', 'internal', undefined, [visMod]); + const nameNode = mockNode('identifier', 'moduleOnly'); + const fnDecl = mockNode('function_declaration', 'internal fun moduleOnly() {}', undefined, [modifiers, nameNode]); + expect(isNodeExported(nameNode, 'moduleOnly', 'kotlin')).toBe(false); + }); + }); + + // C# additional cases + describe('csharp additional', () => { + it('internal modifier is not exported', () => { + const modifier = mockNode('modifier', 'internal'); + const nameNode = mockNode('identifier', 'InternalService'); + const classDecl = mockNode('class_declaration', 'internal class InternalService {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'InternalService', 'csharp')).toBe(false); + }); + + it('private modifier is not exported', () => { + const modifier = mockNode('modifier', 'private'); + const nameNode = mockNode('identifier', 'helper'); + const methodDecl = mockNode('method_declaration', 'private void helper() {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'helper', 'csharp')).toBe(false); + }); + + it('struct with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'Point'); + const structDecl = mockNode('struct_declaration', 'public struct Point {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'Point', 'csharp')).toBe(true); + }); + + it('enum with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'Status'); + const enumDecl = mockNode('enum_declaration', 'public enum Status {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'Status', 'csharp')).toBe(true); + }); + + it('record with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'UserDto'); + const recordDecl = mockNode('record_declaration', 'public record UserDto {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'UserDto', 'csharp')).toBe(true); + }); + + it('interface with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'IService'); + const ifaceDecl = mockNode('interface_declaration', 'public interface IService {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'IService', 'csharp')).toBe(true); + }); + }); + + // Rust additional cases + describe('rust additional', () => { + it('pub(crate) is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub(crate)'); + const nameNode = mockNode('identifier', 'internal_fn'); + const fnDecl = mockNode('function_item', 'pub(crate) fn internal_fn() {}', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'internal_fn', 'rust')).toBe(true); + }); + + it('pub struct is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub'); + const nameNode = mockNode('type_identifier', 'Config'); + const structDecl = mockNode('struct_item', 'pub struct Config {}', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'Config', 'rust')).toBe(true); + }); + + it('private struct is not exported', () => { + const nameNode = mockNode('type_identifier', 'Inner'); + const structDecl = mockNode('struct_item', 'struct Inner {}', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'Inner', 'rust')).toBe(false); + }); + + it('pub enum is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub'); + const nameNode = mockNode('type_identifier', 'ErrorKind'); + const enumDecl = mockNode('enum_item', 'pub enum ErrorKind {}', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'ErrorKind', 'rust')).toBe(true); + }); + + it('pub trait is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub'); + const nameNode = mockNode('type_identifier', 'Handler'); + const traitDecl = mockNode('trait_item', 'pub trait Handler {}', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'Handler', 'rust')).toBe(true); + }); + }); + + // C/C++ additional cases + describe('c/cpp additional', () => { + it('static C++ function is not exported', () => { + const nameNode = mockNode('identifier', 'localHelper'); + const staticSpec = mockNode('storage_class_specifier', 'static'); + const fnDef = mockNode('function_definition', 'static int localHelper() {}', undefined, [staticSpec, nameNode]); + expect(isNodeExported(nameNode, 'localHelper', 'cpp')).toBe(false); + }); + + it('declaration (not definition) without static is exported', () => { + const nameNode = mockNode('identifier', 'compute'); + const decl = mockNode('declaration', 'int compute(int x);', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'compute', 'c')).toBe(true); + }); + + it('static declaration is not exported', () => { + const nameNode = mockNode('identifier', 'internalFn'); + const staticSpec = mockNode('storage_class_specifier', 'static'); + const decl = mockNode('declaration', 'static int internalFn(void);', undefined, [staticSpec, nameNode]); + expect(isNodeExported(nameNode, 'internalFn', 'c')).toBe(false); + }); + + it('detached node defaults to exported (external linkage)', () => { + const nameNode = mockNode('identifier', 'orphan'); + expect(isNodeExported(nameNode, 'orphan', 'c')).toBe(true); + }); + + it('C++ anonymous namespace function is not exported (internal linkage)', () => { + const nameNode = mockNode('identifier', 'anonHelper'); + const fnDef = mockNode('function_definition', 'void anonHelper() {}', undefined, [nameNode]); + // Anonymous namespace: namespace_definition with no name field + const anonNs = mockNode('namespace_definition', 'namespace { void anonHelper() {} }', undefined, [fnDef]); + expect(isNodeExported(nameNode, 'anonHelper', 'cpp')).toBe(false); + }); + + it('C++ named namespace function is still exported', () => { + const nameNode = mockNode('identifier', 'namedHelper'); + const fnDef = mockNode('function_definition', 'void namedHelper() {}', undefined, [nameNode]); + const nsName = mockNode('namespace_identifier', 'utils'); + const namedNs = mockNode('namespace_definition', 'namespace utils { void namedHelper() {} }', undefined, [fnDef], { name: nsName }); + expect(isNodeExported(nameNode, 'namedHelper', 'cpp')).toBe(true); + }); + }); + + // C/C++ with real tree-sitter (validates structural storage_class_specifier detection) + describe('c/cpp real tree-sitter', () => { + it('non-static function is exported using real AST', async () => { + const parser = await loadParser(); + await loadLanguage(SupportedLanguages.C); + const tree = parser.parse('int add(int a, int b) { return a + b; }'); + const funcDef = tree.rootNode.child(0)!; + // Find the identifier name node inside the function_definition + const declNode = funcDef.childForFieldName('declarator'); + const nameNode = declNode?.childForFieldName?.('declarator') || declNode; + expect(isNodeExported(nameNode, 'add', 'c')).toBe(true); + }); + + it('static function is not exported using real AST', async () => { + const parser = await loadParser(); + await loadLanguage(SupportedLanguages.C); + const tree = parser.parse('static int internal_helper(void) { return 0; }'); + const funcDef = tree.rootNode.child(0)!; + const declNode = funcDef.childForFieldName('declarator'); + const nameNode = declNode?.childForFieldName?.('declarator') || declNode; + expect(isNodeExported(nameNode, 'internal_helper', 'c')).toBe(false); + }); + + it('extern function is exported using real AST', async () => { + const parser = await loadParser(); + await loadLanguage(SupportedLanguages.C); + const tree = parser.parse('extern int shared_func(void);'); + const decl = tree.rootNode.child(0)!; + // Declaration nodes should not have storage_class_specifier 'static' + const nameNode = decl.descendantsOfType?.('identifier')?.[0] || decl; + expect(isNodeExported(nameNode, 'shared_func', 'c')).toBe(true); + }); + + it('C++ anonymous namespace detected via real AST', async () => { + const parser = await loadParser(); + await loadLanguage(SupportedLanguages.CPlusPlus); + const code = 'namespace { void hidden() {} }'; + const tree = parser.parse(code); + const nsDef = tree.rootNode.child(0)!; + // Find function_definition inside the namespace body + const body = nsDef.childForFieldName('body'); + const funcDef = body?.namedChild(0); + const declNode = funcDef?.childForFieldName?.('declarator'); + const nameNode = declNode?.childForFieldName?.('declarator') || declNode; + expect(isNodeExported(nameNode, 'hidden', 'cpp')).toBe(false); + }); + + it('C++ named namespace is still exported via real AST', async () => { + const parser = await loadParser(); + await loadLanguage(SupportedLanguages.CPlusPlus); + const code = 'namespace utils { void helper() {} }'; + const tree = parser.parse(code); + const nsDef = tree.rootNode.child(0)!; + const body = nsDef.childForFieldName('body'); + const funcDef = body?.namedChild(0); + const declNode = funcDef?.childForFieldName?.('declarator'); + const nameNode = declNode?.childForFieldName?.('declarator') || declNode; + expect(isNodeExported(nameNode, 'helper', 'cpp')).toBe(true); + }); + }); + + // C/C++ edge cases with mocks + describe('c/cpp edge cases', () => { + it('nested anonymous namespace (double nesting) is not exported', () => { + const nameNode = mockNode('identifier', 'deepHidden'); + const fnDef = mockNode('function_definition', 'void deepHidden() {}', undefined, [nameNode]); + const innerNs = mockNode('namespace_definition', 'namespace { }', undefined, [fnDef]); + const outerNs = mockNode('namespace_definition', 'namespace outer { }', undefined, [innerNs], { name: mockNode('namespace_identifier', 'outer') }); + expect(isNodeExported(nameNode, 'deepHidden', 'cpp')).toBe(false); + }); + + it('static function inside named namespace is not exported', () => { + const nameNode = mockNode('identifier', 'staticInNs'); + const staticSpec = mockNode('storage_class_specifier', 'static'); + const fnDef = mockNode('function_definition', 'static void staticInNs() {}', undefined, [staticSpec, nameNode]); + const ns = mockNode('namespace_definition', 'namespace foo { }', undefined, [fnDef], { name: mockNode('namespace_identifier', 'foo') }); + expect(isNodeExported(nameNode, 'staticInNs', 'cpp')).toBe(false); + }); + + it('extern storage class is not confused with static', () => { + const nameNode = mockNode('identifier', 'externFn'); + const externSpec = mockNode('storage_class_specifier', 'extern'); + const fnDef = mockNode('function_definition', 'extern void externFn() {}', undefined, [externSpec, nameNode]); + expect(isNodeExported(nameNode, 'externFn', 'c')).toBe(true); + }); + }); + + // Rust additional edge cases + describe('rust edge cases', () => { + it('pub(super) is treated as exported', () => { + const visMod = mockNode('visibility_modifier', 'pub(super)'); + const nameNode = mockNode('identifier', 'parent_fn'); + const fnDecl = mockNode('function_item', 'pub(super) fn parent_fn() {}', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'parent_fn', 'rust')).toBe(true); + }); + + it('pub union is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub'); + const nameNode = mockNode('type_identifier', 'MyUnion'); + const unionDecl = mockNode('union_item', 'pub union MyUnion {}', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'MyUnion', 'rust')).toBe(true); + }); + + it('private union is not exported', () => { + const nameNode = mockNode('type_identifier', 'InternalUnion'); + const unionDecl = mockNode('union_item', 'union InternalUnion {}', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'InternalUnion', 'rust')).toBe(false); + }); + + it('pub type alias is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub'); + const nameNode = mockNode('type_identifier', 'Result'); + const typeDecl = mockNode('type_item', 'pub type Result = ...', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'Result', 'rust')).toBe(true); + }); + + it('pub const is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub'); + const nameNode = mockNode('identifier', 'MAX_SIZE'); + const constDecl = mockNode('const_item', 'pub const MAX_SIZE: usize = 100;', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'MAX_SIZE', 'rust')).toBe(true); + }); + + it('private const is not exported', () => { + const nameNode = mockNode('identifier', 'INTERNAL_LIMIT'); + const constDecl = mockNode('const_item', 'const INTERNAL_LIMIT: usize = 50;', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'INTERNAL_LIMIT', 'rust')).toBe(false); + }); + + it('pub static is exported', () => { + const visMod = mockNode('visibility_modifier', 'pub'); + const nameNode = mockNode('identifier', 'INSTANCE'); + const staticDecl = mockNode('static_item', 'pub static INSTANCE: ...', undefined, [visMod, nameNode]); + expect(isNodeExported(nameNode, 'INSTANCE', 'rust')).toBe(true); + }); + + it('associated_type without pub is not exported', () => { + const nameNode = mockNode('type_identifier', 'Item'); + const assocType = mockNode('associated_type', 'type Item;', undefined, [nameNode]); + expect(isNodeExported(nameNode, 'Item', 'rust')).toBe(false); + }); + }); + + // C# edge cases + describe('csharp edge cases', () => { + it('protected modifier is not exported', () => { + const modifier = mockNode('modifier', 'protected'); + const nameNode = mockNode('identifier', 'OnInit'); + const methodDecl = mockNode('method_declaration', 'protected void OnInit() {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'OnInit', 'csharp')).toBe(false); + }); + + it('protected internal is not exported (first modifier wins)', () => { + const mod1 = mockNode('modifier', 'protected'); + const mod2 = mockNode('modifier', 'internal'); + const nameNode = mockNode('identifier', 'Setup'); + const methodDecl = mockNode('method_declaration', 'protected internal void Setup() {}', undefined, [mod1, mod2, nameNode]); + // Neither modifier is 'public', so not exported + expect(isNodeExported(nameNode, 'Setup', 'csharp')).toBe(false); + }); + + it('record_struct with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'Coord'); + const recStruct = mockNode('record_struct_declaration', 'public record struct Coord {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'Coord', 'csharp')).toBe(true); + }); + + it('record_class with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'UserRecord'); + const recClass = mockNode('record_class_declaration', 'public record class UserRecord {}', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'UserRecord', 'csharp')).toBe(true); + }); + + it('file_scoped_namespace_declaration is a valid context', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'MyClass'); + const classDecl = mockNode('class_declaration', 'public class MyClass {}', undefined, [modifier, nameNode]); + // class_declaration is found before namespace, so public is detected + expect(isNodeExported(nameNode, 'MyClass', 'csharp')).toBe(true); + }); + + it('delegate with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'OnChange'); + const delegateDecl = mockNode('delegate_declaration', 'public delegate void OnChange();', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'OnChange', 'csharp')).toBe(true); + }); + + it('event with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'Changed'); + const eventDecl = mockNode('event_declaration', 'public event EventHandler Changed;', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'Changed', 'csharp')).toBe(true); + }); + + it('property with public modifier is exported', () => { + const modifier = mockNode('modifier', 'public'); + const nameNode = mockNode('identifier', 'Name'); + const propDecl = mockNode('property_declaration', 'public string Name { get; set; }', undefined, [modifier, nameNode]); + expect(isNodeExported(nameNode, 'Name', 'csharp')).toBe(true); + }); + }); + + // Kotlin edge cases + describe('kotlin edge cases', () => { + it('protected function is not exported', () => { + const visMod = mockNode('visibility_modifier', 'protected'); + const modifiers = mockNode('modifiers', 'protected', undefined, [visMod]); + const nameNode = mockNode('identifier', 'onInit'); + const fnDecl = mockNode('function_declaration', 'protected fun onInit() {}', undefined, [modifiers, nameNode]); + expect(isNodeExported(nameNode, 'onInit', 'kotlin')).toBe(false); + }); + }); + + // Java edge cases + describe('java edge cases', () => { + it('protected method is not exported', () => { + const modifiers = mockNode('modifiers', 'protected'); + const nameNode = mockNode('identifier', 'onInit'); + const methodDecl = mockNode('method_declaration', 'protected void onInit() {}', undefined, [modifiers, nameNode]); + expect(isNodeExported(nameNode, 'onInit', 'java')).toBe(false); + }); + + it('static public method is exported', () => { + const modifiers = mockNode('modifiers', 'public static'); + const nameNode = mockNode('identifier', 'main'); + const methodDecl = mockNode('method_declaration', 'public static void main(String[] args) {}', undefined, [modifiers, nameNode]); + expect(isNodeExported(nameNode, 'main', 'java')).toBe(true); + }); + }); + + // PHP edge cases + describe('php edge cases', () => { + it('protected method is not exported', () => { + const visMod = mockNode('visibility_modifier', 'protected'); + const nameNode = mockNode('name', 'init', visMod); + expect(isNodeExported(nameNode, 'init', 'php')).toBe(false); + }); + + it('interface declaration is exported', () => { + const ifaceDecl = mockNode('interface_declaration', 'interface Loggable {}'); + const nameNode = mockNode('name', 'Loggable', ifaceDecl); + expect(isNodeExported(nameNode, 'Loggable', 'php')).toBe(true); + }); + + it('trait declaration is exported', () => { + const traitDecl = mockNode('trait_declaration', 'trait Cacheable {}'); + const nameNode = mockNode('name', 'Cacheable', traitDecl); + expect(isNodeExported(nameNode, 'Cacheable', 'php')).toBe(true); + }); + + it('enum declaration is exported', () => { + const enumDecl = mockNode('enum_declaration', 'enum Status {}'); + const nameNode = mockNode('name', 'Status', enumDecl); + expect(isNodeExported(nameNode, 'Status', 'php')).toBe(true); + }); + }); + + // Swift edge cases + describe('swift edge cases', () => { + it('internal function is not exported (Swift default)', () => { + const visMod = mockNode('visibility_modifier', 'internal'); + const nameNode = mockNode('identifier', 'setup', visMod); + expect(isNodeExported(nameNode, 'setup', 'swift')).toBe(false); + }); + + it('private function is not exported', () => { + const visMod = mockNode('visibility_modifier', 'private'); + const nameNode = mockNode('identifier', 'helper', visMod); + expect(isNodeExported(nameNode, 'helper', 'swift')).toBe(false); + }); + + it('fileprivate function is not exported', () => { + const visMod = mockNode('visibility_modifier', 'fileprivate'); + const nameNode = mockNode('identifier', 'localHelper', visMod); + expect(isNodeExported(nameNode, 'localHelper', 'swift')).toBe(false); + }); + }); + + // Unknown language + describe('unknown language', () => { + it('returns false for unknown language', () => { + const node = mockNode('identifier', 'foo'); + expect(isNodeExported(node, 'foo', 'unknown')).toBe(false); + }); + }); + }); + + // ─── Fixture files exist ───────────────────────────────────────────── + + describe('fixture files', () => { + const fixtures = ['simple.ts', 'simple.py', 'simple.go', 'simple.swift', + 'simple.php', 'simple.rs', 'simple.java', 'simple.c', 'simple.cpp', 'simple.cs']; + + for (const fixture of fixtures) { + it(`${fixture} exists and is non-empty`, async () => { + const content = await fs.readFile(path.join(FIXTURES_DIR, fixture), 'utf-8'); + expect(content.length).toBeGreaterThan(0); + }); + } + }); + + // ─── Unhappy path ───────────────────────────────────────────────────── + + describe('unhappy path', () => { + it('returns empty AST or handles empty file content', async () => { + const parser = await loadParser(); + await loadLanguage(SupportedLanguages.TypeScript, 'empty.ts'); + + // Parsing a zero-length string must not throw and must return a valid tree. + const tree = parser.parse(''); + expect(tree).toBeDefined(); + expect(tree.rootNode).toBeDefined(); + + // An empty file produces a root node with no named children — no symbols. + // isNodeExported on a bare node with no ancestors returns false regardless of language. + const detachedNode = mockNode('identifier', 'foo'); + expect(isNodeExported(detachedNode, 'foo', 'typescript')).toBe(false); + }); + + it('handles binary/non-UTF8 content gracefully', async () => { + const parser = await loadParser(); + await loadLanguage(SupportedLanguages.TypeScript, 'binary.ts'); + + // Construct a string that contains the Unicode replacement character (U+FFFD) + // and a mix of high-byte sequences that are not valid UTF-8 when treated as Latin-1. + // JavaScript strings are UTF-16 internally, so this is always a valid string — + // but it exercises tree-sitter's ability to handle unusual byte patterns. + const binaryLikeContent = '\uFFFD\u0000\u0001\u001F' + '\xFF\xFE'.repeat(10) + '\uFFFD'; + + // Must not throw — tree-sitter should return an error-recovery tree. + let tree: any; + expect(() => { + tree = parser.parse(binaryLikeContent); + }).not.toThrow(); + + expect(tree).toBeDefined(); + expect(tree.rootNode).toBeDefined(); + }); + + it('falls back gracefully for unsupported language', async () => { + // getLanguageFromFilename returns null for extensions with no grammar mapping. + const scalaLang = getLanguageFromFilename('Main.scala'); + expect(scalaLang).toBeNull(); + + const luaLang = getLanguageFromFilename('module.lua'); + expect(luaLang).toBeNull(); + + // loadLanguage throws an explicit error for a language not in the grammar map. + // Cast through unknown to simulate a caller passing an unrecognised language key. + await expect( + loadLanguage('erlang' as unknown as SupportedLanguages) + ).rejects.toThrow('Unsupported language'); + }); + }); +}); diff --git a/gitnexus/test/integration/pipeline.test.ts b/gitnexus/test/integration/pipeline.test.ts new file mode 100644 index 0000000000..0fa8e0b3cc --- /dev/null +++ b/gitnexus/test/integration/pipeline.test.ts @@ -0,0 +1,191 @@ +/** + * P1 Integration Tests: Pipeline End-to-End + * + * Runs the full ingestion pipeline once on a mini-repo fixture and + * validates the resulting knowledge graph: file/symbol nodes, CALLS + * edges, IMPORTS edges, community detection, and process detection. + * + * Pipeline runs once in beforeAll; each it() asserts against the cached result. + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import os from 'os'; +import fs from 'fs/promises'; +import { runPipelineFromRepo } from '../../src/core/ingestion/pipeline.js'; +import type { PipelineProgress } from '../../src/types/pipeline.js'; +import type { PipelineResult } from '../../src/types/pipeline.js'; + +const MINI_REPO = path.resolve(__dirname, '..', 'fixtures', 'mini-repo'); + +describe('pipeline end-to-end', () => { + let result: PipelineResult; + const phases = new Set<string>(); + + // Run pipeline ONCE in beforeAll — each it() asserts against the cached result + beforeAll(async () => { + result = await runPipelineFromRepo(MINI_REPO, (p: PipelineProgress) => phases.add(p.phase)); + }, 60000); + + it('indexes a mini repo and produces a valid graph', () => { + // --- Graph should have nodes --- + expect(result.graph.nodeCount).toBeGreaterThan(0); + expect(result.graph.relationshipCount).toBeGreaterThan(0); + + // --- Should find at least 7 TypeScript files (may include AGENTS.md, CLAUDE.md, etc.) --- + expect(result.totalFileCount).toBeGreaterThanOrEqual(7); + + // --- Verify File nodes exist for each source file --- + const fileNodes: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'File') fileNodes.push(n.properties.filePath || n.properties.name); + }); + expect(fileNodes).toContain('src/handler.ts'); + expect(fileNodes).toContain('src/validator.ts'); + expect(fileNodes).toContain('src/db.ts'); + expect(fileNodes).toContain('src/formatter.ts'); + expect(fileNodes).toContain('src/index.ts'); + expect(fileNodes).toContain('src/logger.ts'); + expect(fileNodes).toContain('src/middleware.ts'); + + // --- Verify symbol nodes were created (functions, classes) --- + const symbolNames: string[] = []; + result.graph.forEachNode(n => { + if (['Function', 'Method', 'Class', 'Interface'].includes(n.label)) { + symbolNames.push(n.properties.name); + } + }); + expect(symbolNames).toContain('handleRequest'); + expect(symbolNames).toContain('validateInput'); + expect(symbolNames).toContain('saveToDb'); + expect(symbolNames).toContain('formatResponse'); + expect(symbolNames).toContain('RequestHandler'); + expect(symbolNames).toContain('processRequest'); + expect(symbolNames).toContain('createLogEntry'); + + // --- Verify relationships exist --- + const relTypes = new Set<string>(); + for (const rel of result.graph.iterRelationships()) { + relTypes.add(rel.type); + } + // Should have at least CONTAINS (structure) and CALLS (call graph) + expect(relTypes).toContain('CONTAINS'); + + // --- Verify CALLS edges were detected --- + const callEdges: { source: string; target: string }[] = []; + for (const rel of result.graph.iterRelationships()) { + if (rel.type === 'CALLS') { + const sourceNode = result.graph.getNode(rel.sourceId); + const targetNode = result.graph.getNode(rel.targetId); + if (sourceNode && targetNode) { + callEdges.push({ + source: sourceNode.properties.name, + target: targetNode.properties.name, + }); + } + } + } + expect(callEdges.length).toBeGreaterThan(0); + + // handleRequest should call validateInput, saveToDb, formatResponse + const handleRequestCalls = callEdges.filter(e => e.source === 'handleRequest'); + const calledByHandler = handleRequestCalls.map(e => e.target); + expect(calledByHandler).toContain('validateInput'); + expect(calledByHandler).toContain('saveToDb'); + expect(calledByHandler).toContain('formatResponse'); + + // --- Verify IMPORTS edges --- + let importsCount = 0; + for (const rel of result.graph.iterRelationships()) { + if (rel.type === 'IMPORTS') importsCount++; + } + expect(importsCount).toBeGreaterThan(0); + }); + + it('detects communities', () => { + expect(result.communityResult).toBeDefined(); + expect(result.communityResult?.stats.totalCommunities).toBeGreaterThan(0); + + // Community nodes should be in the graph + const communityNodes: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Community') communityNodes.push(n.properties.name); + }); + expect(communityNodes.length).toBeGreaterThan(0); + + // MEMBER_OF relationships should exist + let memberOfCount = 0; + for (const rel of result.graph.iterRelationships()) { + if (rel.type === 'MEMBER_OF') memberOfCount++; + } + expect(memberOfCount).toBeGreaterThan(0); + }); + + it('detects execution flows (processes)', () => { + expect(result.processResult).toBeDefined(); + expect(result.processResult?.stats.totalProcesses).toBeGreaterThan(0); + + const proc = result.processResult?.processes[0] ?? { id: '', stepCount: 0, trace: [], entryPointId: '', terminalId: '', processType: '' }; + + // Each process should have valid structure + expect(proc.id).toBeTruthy(); + expect(proc.stepCount).toBeGreaterThanOrEqual(3); // minSteps default + expect(proc.trace.length).toBe(proc.stepCount); + expect(proc.entryPointId).toBeTruthy(); + expect(proc.terminalId).toBeTruthy(); + expect(proc.processType).toMatch(/^(intra_community|cross_community)$/); + + // Process nodes should be in the graph + const processNode = result.graph.getNode(proc.id); + expect(processNode).toBeDefined(); + expect(processNode!.label).toBe('Process'); + + // STEP_IN_PROCESS relationships should exist with sequential ordering + const steps: number[] = []; + for (const rel of result.graph.iterRelationships()) { + if (rel.type === 'STEP_IN_PROCESS' && rel.targetId === proc.id) { + steps.push(rel.step); + } + } + expect(steps.length).toBe(proc.stepCount); + // Steps should be sequential 1, 2, 3, ... + const sorted = [...steps].sort((a, b) => a - b); + sorted.forEach((s, i) => expect(s).toBe(i + 1)); + }); + + it('reports progress through all 6 phases', () => { + expect(phases).toContain('extracting'); + expect(phases).toContain('structure'); + expect(phases).toContain('parsing'); + expect(phases).toContain('communities'); + expect(phases).toContain('processes'); + expect(phases).toContain('complete'); + }); + + it('returns correct repoPath in result', () => { + expect(result.repoPath).toBe(MINI_REPO); + }); +}); + +// ─── Pipeline error handling ────────────────────────────────────────── + +describe('pipeline error handling', () => { + it('returns empty result for non-existent repo path', async () => { + const result = await runPipelineFromRepo( + '/nonexistent/path/xyz123', + () => {}, + ); + expect(result.totalFileCount).toBe(0); + }, 30000); + + it('handles empty directory gracefully', async () => { + const tmpDir = path.join(os.tmpdir(), `gn-pipeline-empty-${Date.now()}`); + await fs.mkdir(tmpDir, { recursive: true }); + try { + const result = await runPipelineFromRepo(tmpDir, () => {}); + // Empty repo should produce empty or minimal graph + expect(result.totalFileCount).toBe(0); + } finally { + await fs.rm(tmpDir, { recursive: true, force: true }); + } + }, 30000); +}); diff --git a/gitnexus/test/integration/query-compilation.test.ts b/gitnexus/test/integration/query-compilation.test.ts new file mode 100644 index 0000000000..ac7453b973 --- /dev/null +++ b/gitnexus/test/integration/query-compilation.test.ts @@ -0,0 +1,61 @@ +import { describe, it, expect, beforeAll } from 'vitest'; +import { loadParser, loadLanguage, isLanguageAvailable } from '../../src/core/tree-sitter/parser-loader.js'; +import { LANGUAGE_QUERIES } from '../../src/core/ingestion/tree-sitter-queries.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; +import Parser from 'tree-sitter'; + +/** + * Smoke test: verify that every LANGUAGE_QUERIES entry compiles against + * its tree-sitter grammar without throwing. A silent Query compilation + * failure is the #1 cause of "0 nodes extracted for language X" bugs. + */ +describe('Query compilation smoke tests', () => { + let parser: Parser; + + beforeAll(async () => { + parser = await loadParser(); + }); + + const languageFiles: Record<string, string> = { + [SupportedLanguages.TypeScript]: 'test.ts', + [SupportedLanguages.JavaScript]: 'test.js', + [SupportedLanguages.Python]: 'test.py', + [SupportedLanguages.Java]: 'Test.java', + [SupportedLanguages.C]: 'test.c', + [SupportedLanguages.CPlusPlus]: 'test.cpp', + [SupportedLanguages.CSharp]: 'Test.cs', + [SupportedLanguages.Go]: 'test.go', + [SupportedLanguages.Rust]: 'test.rs', + [SupportedLanguages.PHP]: 'test.php', + [SupportedLanguages.Kotlin]: 'Test.kt', + [SupportedLanguages.Swift]: 'test.swift', + }; + + // Known query compilation failures — remove from this set as PRs fix them + const knownFailures = new Set<string>([]); + + for (const [lang, filename] of Object.entries(languageFiles)) { + const testFn = knownFailures.has(lang) ? it.fails : it; + + testFn(`compiles query for ${lang}`, async () => { + if (!isLanguageAvailable(lang as SupportedLanguages)) { + return; // parser binary not available in this environment + } + + await loadLanguage(lang as SupportedLanguages, filename); + const queryStr = LANGUAGE_QUERIES[lang as SupportedLanguages]; + expect(queryStr).toBeTruthy(); + + const grammar = parser.getLanguage(); + // This is the line that silently fails in production when queries + // use node types that don't exist in the grammar. + const query = new Parser.Query(grammar, queryStr); + expect(query).toBeDefined(); + + // Verify it can actually run against a minimal tree + const tree = parser.parse(''); + const matches = query.matches(tree.rootNode); + expect(Array.isArray(matches)).toBe(true); + }); + } +}); diff --git a/gitnexus/test/integration/resolvers/cpp.test.ts b/gitnexus/test/integration/resolvers/cpp.test.ts new file mode 100644 index 0000000000..020366059c --- /dev/null +++ b/gitnexus/test/integration/resolvers/cpp.test.ts @@ -0,0 +1,971 @@ +/** + * C++: diamond inheritance + include-based imports + ambiguous #include disambiguation + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: diamond inheritance + include-based imports +// --------------------------------------------------------------------------- + +describe('C++ diamond inheritance', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-diamond'), + () => {}, + ); + }, 60000); + + it('detects exactly 4 classes in diamond hierarchy', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Animal', 'Duck', 'Flyer', 'Swimmer']); + }); + + it('emits exactly 4 EXTENDS edges for full diamond', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(4); + expect(edgeSet(extends_)).toEqual([ + 'Duck → Flyer', + 'Duck → Swimmer', + 'Flyer → Animal', + 'Swimmer → Animal', + ]); + }); + + it('resolves all 5 #include imports between header/source files', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(5); + expect(edgeSet(imports)).toEqual([ + 'duck.cpp → duck.h', + 'duck.h → flyer.h', + 'duck.h → swimmer.h', + 'flyer.h → animal.h', + 'swimmer.h → animal.h', + ]); + }); + + it('captures 1 Method node from duck.cpp (speak)', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toEqual(['speak']); + }); + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: two headers with same class name, #include disambiguates +// --------------------------------------------------------------------------- + +describe('C++ ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes.filter(n => n === 'Handler').length).toBe(2); + expect(classes).toContain('Processor'); + }); + + it('resolves EXTENDS to handler_a.h (not handler_b.h)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('Processor'); + expect(extends_[0].target).toBe('Handler'); + expect(extends_[0].targetFilePath).toBe('handler_a.h'); + }); + + it('#include resolves to handler_a.h', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(1); + expect(imports[0].targetFilePath).toBe('handler_a.h'); + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of getRelationships(result, 'EXTENDS')) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +describe('C++ call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-calls'), + () => {}, + ); + }, 60000); + + it('resolves run → write_audit to one.h via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('run'); + expect(calls[0].target).toBe('write_audit'); + expect(calls[0].targetFilePath).toBe('one.h'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('C++ member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves processUser → save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + expect(saveCall!.targetFilePath).toBe('user.h'); + }); + + it('detects User class and save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('emits HAS_METHOD edge from User to save', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'User' && e.target === 'save'); + expect(edge).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor resolution: new Foo() resolves to Class +// --------------------------------------------------------------------------- + +describe('C++ constructor-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-constructor-calls'), + () => {}, + ); + }, 60000); + + it('resolves new User() as a CALLS edge to the User class', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.source).toBe('processUser'); + expect(ctorCall!.targetLabel).toBe('Class'); + expect(ctorCall!.targetFilePath).toBe('user.h'); + expect(ctorCall!.rel.reason).toBe('import-resolved'); + }); + + it('detects User class and save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('resolves #include import', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(1); + expect(imports[0].targetFilePath).toBe('user.h'); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed variables disambiguate same-named methods +// --------------------------------------------------------------------------- + +describe('C++ receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User.save and repo.save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'user.h'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'repo.h'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + expect(repoSave!.source).toBe('processEntities'); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: auto user = User(); user.save() → User.save +// Cross-file SymbolTable verification (no explicit type annotations) +// --------------------------------------------------------------------------- + +describe('C++ constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to models/User.h via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/User.h'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.save() to models/Repo.h via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/Repo.h'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Variadic resolution: C-style variadic (...) doesn't get filtered by arity +// --------------------------------------------------------------------------- + +describe('C++ variadic call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-variadic-resolution'), + () => {}, + ); + }, 60000); + + it('resolves 3-arg call to variadic function log_entry(const char*, ...) in logger.h', () => { + const calls = getRelationships(result, 'CALLS'); + const logCall = calls.find(c => c.target === 'log_entry'); + expect(logCall).toBeDefined(); + expect(logCall!.source).toBe('main'); + expect(logCall!.targetFilePath).toBe('logger.h'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('C++ local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves run → save to same-file definition, not the imported one', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'run'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/main.cpp'); + }); + + it('does NOT resolve save to utils.h', () => { + const calls = getRelationships(result, 'CALLS'); + const saveToUtils = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/utils.h'); + expect(saveToUtils).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// this->save() resolves to enclosing class's own save method +// --------------------------------------------------------------------------- + +describe('C++ this resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves this->save() to User::save in the same file (not Repo::save)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/User.cpp'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS via base_class_clause +// --------------------------------------------------------------------------- + +describe('C++ parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('BaseModel'); + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('emits EXTENDS edge: User → BaseModel (base_class_clause)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); +}); + +// --------------------------------------------------------------------------- +// Brace-init constructor inference: auto x = User{}; x.save() → User.save +// --------------------------------------------------------------------------- + +describe('C++ brace-init constructor inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-brace-init-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User.save via brace-init', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/User.h'); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() to Repo.save via brace-init', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/Repo.h'); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// C++ scoped brace-init: auto x = ns::HttpClient{} +// --------------------------------------------------------------------------- + +describe('C++ scoped brace-init resolution (ns::Type{})', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-scoped-brace-init'), + () => {}, + ); + }, 60000); + + it('resolves client.connect() via ns::HttpClient{} scoped brace-init', () => { + const calls = getRelationships(result, 'CALLS'); + const connectCall = calls.find(c => c.target === 'connect' && c.targetFilePath === 'models.h'); + expect(connectCall).toBeDefined(); + expect(connectCall!.source).toBe('run'); + }); + + it('resolves client.send() via ns::HttpClient{} scoped brace-init', () => { + const calls = getRelationships(result, 'CALLS'); + const sendCall = calls.find(c => c.target === 'send' && c.targetFilePath === 'models.h'); + expect(sendCall).toBeDefined(); + expect(sendCall!.source).toBe('run'); + }); +}); + +// --------------------------------------------------------------------------- +// C++ range-based for: for (auto& user : users) — Tier 1c +// --------------------------------------------------------------------------- + +describe('C++ range-based for loop resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-range-for'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() in range-for to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in const auto& range-for to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('Repo'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: auto user = getUser("alice"); user.save() +// C++'s CONSTRUCTOR_BINDING_SCANNER captures auto declarations with +// call_expression values, enabling return type inference from function results. +// --------------------------------------------------------------------------- + +describe('C++ return type inference via auto + function call', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-return-type'), + () => {}, + ); + }, 60000); + + it('detects User class and getUser function', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Function')).toContain('getUser'); + }); + + it('detects save method on User', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('save'); + }); + + it('resolves user.save() to User#save via return type of getUser(): User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('user.h'), + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Return-type inference with competing methods: +// Two classes both have save(), factory functions disambiguate via return type +// --------------------------------------------------------------------------- + +describe('C++ return-type inference via function return type', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-return-type-inference'), + () => {}, + ); + }, 60000); + + it('resolves user.save() to User#save via return type of getUser()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('user.h') + ); + expect(saveCall).toBeDefined(); + }); + + it('user.save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUser' + ); + // Should resolve to exactly one target — if it resolves at all, check it's the right one + if (wrongSave) { + expect(wrongSave.targetFilePath).toContain('user.h'); + } + }); + + it('resolves repo.save() to Repo#save via return type of getRepo()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath.includes('repo.h') + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable receiver unwrapping: User* pointer type stripped for resolution +// --------------------------------------------------------------------------- + +describe('C++ nullable receiver resolution (pointer types)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter((m: string) => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user->save() to User#save via pointer receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('User.h'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo->save() to Repo#save via pointer receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('Repo.h'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-contaminate (exactly 1 save per receiver file)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save' && c.source === 'processEntities'); + const userTargeted = saveCalls.filter(c => c.targetFilePath.includes('User.h')); + const repoTargeted = saveCalls.filter(c => c.targetFilePath.includes('Repo.h')); + expect(userTargeted.length).toBe(1); + expect(repoTargeted.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// C++ assignment chain propagation: auto alias = u; alias.save() +// Tests extractPendingAssignment for C++ auto declarations. +// --------------------------------------------------------------------------- + +describe('C++ assignment chain propagation (auto alias)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves alias.save() to User#save via auto assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath?.includes('User.h'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves rAlias.save() to Repo#save via auto assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath?.includes('Repo.h'), + ); + expect(repoSave).toBeDefined(); + }); + + it('each alias resolves to its own class, not the other', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save' && c.source === 'processEntities'); + const userTargeted = saveCalls.filter(c => c.targetFilePath?.includes('User.h')); + const repoTargeted = saveCalls.filter(c => c.targetFilePath?.includes('Repo.h')); + expect(userTargeted.length).toBe(1); + expect(repoTargeted.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method calls: svc.getUser().save() +// Tests that C++ chain call resolution correctly infers the intermediate +// receiver type from getUser()'s return type and resolves save() to User. +// --------------------------------------------------------------------------- + +describe('C++ chained method call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, and UserService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects getUser and save symbols', () => { + const allSymbols = [ + ...getNodesByLabel(result, 'Function'), + ...getNodesByLabel(result, 'Method'), + ]; + expect(allSymbols).toContain('getUser'); + expect(allSymbols).toContain('save'); + }); + + it('resolves svc.getUser().save() to User#save via chain resolution', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath?.includes('user.h'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.getUser().save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath?.includes('repo.h'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// C++ structured binding in range-for: for (auto& [key, user] : userMap) +// --------------------------------------------------------------------------- + +describe('C++ structured binding in range-for', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-structured-binding'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() in structured binding for-loop to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUserMap' && c.targetFilePath?.includes('User.h'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in structured binding for-loop to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepoMap' && c.targetFilePath?.includes('Repo.h'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUserMap' && c.targetFilePath?.includes('Repo.h'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('does NOT cross-resolve repo.save() to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processRepoMap' && c.targetFilePath?.includes('User.h'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// C++ pointer dereference in range-for: for (auto& user : *ptr) +// --------------------------------------------------------------------------- + +describe('C++ pointer dereference in range-for', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-deref-range-for'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() in *usersPtr range-for to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in *reposPtr range-for to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('Repo'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution (1-level) +// --------------------------------------------------------------------------- + +describe('Field type resolution (C++)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'User']); + }); + + it('detects Property nodes for C++ data member fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking fields to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('Address → city'); + }); + + it('resolves user.address.save() → Address#save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find( + e => e.source === 'processUser' && e.targetFilePath.includes('models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8A: Deep field chain resolution (3-level) +// --------------------------------------------------------------------------- + +describe('Deep field chain resolution (C++)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-deep-field-chain'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, City, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'City', 'User']); + }); + + it('detects Property nodes for all typed fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('city'); + expect(properties).toContain('zipCode'); + }); + + it('emits HAS_PROPERTY edges for nested type chain', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('Address → city'); + expect(edgeSet(propEdges)).toContain('City → zipCode'); + }); + + it('resolves 2-level chain: user.address.save() → Address#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'processUser'); + const addressSave = saveCalls.find(e => e.targetFilePath.includes('models')); + expect(addressSave).toBeDefined(); + }); + + it('resolves 3-level chain: user.address.city.getName() → City#getName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'getName' && e.source === 'processUser'); + const cityGetName = getNameCalls.find(e => e.targetFilePath.includes('models')); + expect(cityGetName).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Pointer and reference member fields (Address* address; Address& ref_address;) +// --------------------------------------------------------------------------- + +describe('C++ pointer/reference member field capture', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-pointer-ref-fields'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'User']); + }); + + it('detects Property nodes for pointer and reference member fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('ref_address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges for pointer/reference fields', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → ref_address'); + expect(edgeSet(propEdges)).toContain('User → name'); + }); +}); + +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (C++)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'cpp-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for field assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(2); + const fieldNames = writes.map(e => e.target); + expect(fieldNames).toContain('name'); + expect(fieldNames).toContain('address'); + const sources = writes.map(e => e.source); + expect(sources).toContain('updateUser'); + }); + + it('write ACCESSES edges have confidence 1.0', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + for (const edge of writes) { + expect(edge.rel.confidence).toBe(1.0); + } + }); +}); diff --git a/gitnexus/test/integration/resolvers/csharp.test.ts b/gitnexus/test/integration/resolvers/csharp.test.ts new file mode 100644 index 0000000000..e603e239d1 --- /dev/null +++ b/gitnexus/test/integration/resolvers/csharp.test.ts @@ -0,0 +1,1318 @@ +/** + * C#: heritage resolution via base_list + ambiguous namespace-import refusal + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: class + interface resolution via base_list +// --------------------------------------------------------------------------- + +describe('C# heritage resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-proj'), + () => {}, + ); + }, 60000); + + it('detects exactly 3 classes and 2 interfaces', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseEntity', 'User', 'UserService']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['ILogger', 'IRepository']); + }); + + it('emits exactly 1 EXTENDS edge: User → BaseEntity', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseEntity'); + }); + + it('emits exactly 1 IMPLEMENTS edge: User → IRepository', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('User'); + expect(implements_[0].target).toBe('IRepository'); + }); + + it('emits CALLS edges from CreateUser (constructor + member calls)', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(4); + const targets = edgeSet(calls); + expect(targets).toContain('CreateUser → User'); // new User() constructor + expect(targets).toContain('CreateUser → Validate'); // user.Validate() — receiver-typed + expect(targets).toContain('CreateUser → Save'); // _repo.Save() — receiver-typed + expect(targets).toContain('CreateUser → Log'); // _logger.Log() — receiver-typed + }); + + it('resolves all CALLS from CreateUser via import-resolved or unique-global', () => { + const calls = getRelationships(result, 'CALLS'); + // C# non-aliased `using Namespace;` imports don't populate NamedImportMap + // (namespace-scoped imports can't bind to individual symbols). + // Calls resolve via directory-based PackageMap (import-resolved) when ambiguous, + // or via unique-global when the symbol name is globally unique. + for (const call of calls) { + expect(['import-resolved', 'global']).toContain(call.rel.reason); + } + }); + + it('resolves new User() to the User class via constructor discrimination', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.targetLabel).toBe('Class'); + }); + + it('detects 4 namespaces', () => { + const ns = getNodesByLabel(result, 'Namespace'); + expect(ns.length).toBe(4); + }); + + it('detects properties on classes', () => { + const props = getNodesByLabel(result, 'Property'); + expect(props).toContain('Id'); + expect(props).toContain('Name'); + }); + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: using-namespace can't disambiguate same-named types +// --------------------------------------------------------------------------- + +describe('C# ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler classes and 2 IProcessor interfaces', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes.filter(n => n === 'Handler').length).toBe(2); + const ifaces = getNodesByLabel(result, 'Interface'); + expect(ifaces.filter(n => n === 'IProcessor').length).toBe(2); + }); + + it('heritage targets are synthetic (correct refusal for ambiguous namespace import)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + const implements_ = getRelationships(result, 'IMPLEMENTS'); + + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('UserHandler'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('UserHandler'); + + // The key invariant: no edge points to Other/ + if (extends_[0].targetFilePath) { + expect(extends_[0].targetFilePath).not.toMatch(/Other\//); + } + if (implements_[0].targetFilePath) { + expect(implements_[0].targetFilePath).not.toMatch(/Other\//); + } + }); +}); + +describe('C# call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-calls'), + () => {}, + ); + }, 60000); + + it('resolves CreateUser → WriteAudit to Utils/OneArg.cs via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('CreateUser'); + expect(calls[0].target).toBe('WriteAudit'); + expect(calls[0].targetFilePath).toBe('Utils/OneArg.cs'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.Method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('C# member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves ProcessUser → Save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('ProcessUser'); + expect(saveCall!.targetFilePath).toBe('Models/User.cs'); + }); + + it('detects User class and Save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('Save'); + }); + + it('emits HAS_METHOD edge from User to Save', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'User' && e.target === 'Save'); + expect(edge).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Primary constructor resolution: class User(string name, int age) { } +// --------------------------------------------------------------------------- + +describe('C# primary constructor resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-primary-ctors'), + () => {}, + ); + }, 60000); + + it('detects Constructor nodes for primary constructors on class and record', () => { + const ctors = getNodesByLabel(result, 'Constructor'); + expect(ctors).toContain('User'); + expect(ctors).toContain('Person'); + }); + + it('primary constructor has correct parameter count', () => { + let userCtorParams: number | undefined; + let personCtorParams: number | undefined; + result.graph.forEachNode(n => { + if (n.label === 'Constructor' && n.properties.name === 'User') { + userCtorParams = n.properties.parameterCount as number; + } + if (n.label === 'Constructor' && n.properties.name === 'Person') { + personCtorParams = n.properties.parameterCount as number; + } + }); + expect(userCtorParams).toBe(2); + expect(personCtorParams).toBe(2); + }); + + it('resolves new User(...) as a CALLS edge to the Constructor node', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.source).toBe('Run'); + expect(ctorCall!.targetLabel).toBe('Constructor'); + expect(ctorCall!.targetFilePath).toBe('Models/User.cs'); + }); + + it('also resolves user.Save() as a method call', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('Run'); + }); + + it('emits HAS_METHOD edge from User class to User constructor', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'User' && e.target === 'User'); + expect(edge).toBeDefined(); + }); + + it('emits HAS_METHOD edge from Person record to Person constructor', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'Person' && e.target === 'Person'); + expect(edge).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed variables disambiguate same-named methods +// --------------------------------------------------------------------------- + +describe('C# receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with Save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() to User.Save and repo.Save() to Repo.Save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'Models/User.cs'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'Models/Repo.cs'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('ProcessEntities'); + expect(repoSave!.source).toBe('ProcessEntities'); + }); + + it('resolves constructor calls for both User and Repo', () => { + const calls = getRelationships(result, 'CALLS'); + const userCtor = calls.find(c => c.target === 'User'); + const repoCtor = calls.find(c => c.target === 'Repo'); + expect(userCtor).toBeDefined(); + expect(repoCtor).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Alias import resolution: using U = Models.User resolves U → User +// --------------------------------------------------------------------------- + +describe('C# alias import resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-alias-imports'), + () => {}, + ); + }, 60000); + + it('detects Main, Repo, and User classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Main', 'Repo', 'User']); + }); + + it('resolves u.Save() to User.cs and r.Persist() to Repo.cs via alias', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save'); + const persistCall = calls.find(c => c.target === 'Persist'); + + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('Run'); + expect(saveCall!.targetLabel).toBe('Method'); + expect(saveCall!.targetFilePath).toBe('Models/User.cs'); + + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('Run'); + expect(persistCall!.targetLabel).toBe('Method'); + expect(persistCall!.targetFilePath).toBe('Models/Repo.cs'); + }); + + it('emits exactly 2 IMPORTS edges via alias resolution', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(2); + expect(edgeSet(imports)).toEqual([ + 'Main.cs → Repo.cs', + 'Main.cs → User.cs', + ]); + }); +}); + +// --------------------------------------------------------------------------- +// Variadic resolution: params string[] doesn't get filtered by arity +// --------------------------------------------------------------------------- + +describe('C# variadic call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-variadic-resolution'), + () => {}, + ); + }, 60000); + + it('resolves call to params method Record(params string[]) in Logger.cs', () => { + const calls = getRelationships(result, 'CALLS'); + const logCall = calls.find(c => c.target === 'Record'); + expect(logCall).toBeDefined(); + expect(logCall!.source).toBe('Execute'); + expect(logCall!.targetFilePath).toBe('Utils/Logger.cs'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('C# local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves Run → Save to same-file definition, not the imported one', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save' && c.source === 'Run'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('App/Main.cs'); + }); + + it('does NOT resolve Save to Logger.cs', () => { + const calls = getRelationships(result, 'CALLS'); + const saveToUtils = calls.find(c => c.target === 'Save' && c.targetFilePath === 'Utils/Logger.cs'); + expect(saveToUtils).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// For-each loop element typing: foreach (User user in users) user.Save() +// C#: explicit type in foreach_statement binds loop variable +// --------------------------------------------------------------------------- + +describe('C# foreach loop element type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-foreach'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with Save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() in foreach to User#Save (not Repo#Save)', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'Models/User.cs'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('ProcessEntities'); + }); + + it('resolves repo.Save() in foreach to Repo#Save (not User#Save)', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'Models/Repo.cs'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('ProcessEntities'); + }); + + it('emits exactly 2 Save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// this.Save() resolves to enclosing class's own Save method +// --------------------------------------------------------------------------- + +describe('C# this resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a Save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves this.Save() inside User.Process to User.Save, not Repo.Save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save' && c.source === 'Process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/Models/User.cs'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS + IMPLEMENTS via base_list +// --------------------------------------------------------------------------- + +describe('C# parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes plus ISerializable interface', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['ISerializable']); + }); + + it('emits EXTENDS edge: User → BaseModel (from base_list)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits IMPLEMENTS edge: User → ISerializable', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('User'); + expect(implements_[0].target).toBe('ISerializable'); + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +// --------------------------------------------------------------------------- +// base.Save() resolves to parent class's Save method +// --------------------------------------------------------------------------- + +describe('C# base resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-super-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('resolves base.Save() inside User to BaseModel.Save, not Repo.Save', () => { + const calls = getRelationships(result, 'CALLS'); + const baseSave = calls.find(c => c.source === 'Save' && c.target === 'Save' + && c.targetFilePath === 'src/Models/BaseModel.cs'); + expect(baseSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'src/Models/Repo.cs'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// base.Save() resolves to generic parent class's Save method +// --------------------------------------------------------------------------- + +describe('C# generic parent base resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-generic-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('resolves base.Save() inside User to BaseModel.Save, not Repo.Save', () => { + const calls = getRelationships(result, 'CALLS'); + const baseSave = calls.find(c => c.source === 'Save' && c.target === 'Save' + && c.targetFilePath === 'src/Models/BaseModel.cs'); + expect(baseSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'src/Models/Repo.cs'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Pattern matching: `if (animal is Dog dog)` binds `dog` as type `Dog` +// --------------------------------------------------------------------------- + +describe('C# is pattern matching resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-pattern-matching'), + () => {}, + ); + }, 60000); + + it('detects Animal, Dog, and Cat classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('Animal'); + expect(classes).toContain('Dog'); + expect(classes).toContain('Cat'); + }); + + it('detects Bark and Meow methods', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('Bark'); + expect(methods).toContain('Meow'); + }); + + it('resolves dog.Bark() to Dog.Bark via is-pattern type binding', () => { + const calls = getRelationships(result, 'CALLS'); + const barkCall = calls.find(c => c.target === 'Bark'); + expect(barkCall).toBeDefined(); + expect(barkCall!.source).toBe('HandleAnimal'); + expect(barkCall!.targetFilePath).toBe('Models/Animal.cs'); + }); + + it('emits EXTENDS edges for Dog and Cat', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + const dogExtends = extends_.find(e => e.source === 'Dog'); + const catExtends = extends_.find(e => e.source === 'Cat'); + expect(dogExtends).toBeDefined(); + expect(dogExtends!.target).toBe('Animal'); + expect(catExtends).toBeDefined(); + expect(catExtends!.target).toBe('Animal'); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: var user = svc.GetUser("alice"); user.Save() +// C#'s CONSTRUCTOR_BINDING_SCANNER handles `var` declarations with +// invocation_expression values, enabling end-to-end return type inference. +// --------------------------------------------------------------------------- + +describe('C# return type inference via var + invocation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-return-type'), + () => {}, + ); + }, 60000); + + it('detects User, UserService, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('detects Save on both User and Repo, plus GetUser', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('Save'); + expect(methods).toContain('GetUser'); + // Repo.Save is also detected, proving the disambiguation test is meaningful + expect(methods.filter((m: string) => m === 'Save').length).toBe(2); + }); + + it('resolves user.Save() to User#Save (not Repo#Save) via return type of GetUser(): User', () => { + // scanConstructorBinding binds `var user = svc.GetUser()` → calleeName "GetUser". + // processCallsFromExtracted verifies GetUser's returnType is "User" via + // PackageMap resolution of `using ReturnType.Models;`, then receiver filtering + // resolves user.Save() to User#Save (not Repo#Save). + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'Save' && c.source === 'Run' && c.targetFilePath.includes('User.cs'), + ); + expect(saveCall).toBeDefined(); + // Must NOT resolve to Repo.Save — that would mean disambiguation failed + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'Run' && c.targetFilePath.includes('Repo.cs'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +describe('C# null-conditional call resolution (user?.Save())', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-null-conditional'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing Save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter((m: string) => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('captures null-conditional user?.Save() call', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save' && c.source === 'Process'); + expect(saveCalls.length).toBeGreaterThan(0); + }); + + it('resolves user?.Save() to User#Save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'Process' && c.targetFilePath.includes('User.cs'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo?.Save() to Repo#Save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'Process' && c.targetFilePath.includes('Repo.cs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-contaminate (exactly 1 Save per receiver file)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save' && c.source === 'Process'); + const userTargeted = saveCalls.filter(c => c.targetFilePath.includes('User.cs')); + const repoTargeted = saveCalls.filter(c => c.targetFilePath.includes('Repo.cs')); + expect(userTargeted.length).toBe(1); + expect(repoTargeted.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// C# async/await constructor binding resolution +// Verifies that `var user = await svc.GetUserAsync()` correctly unwraps the +// await_expression to find the invocation_expression underneath, producing a +// constructor binding that enables receiver-based disambiguation of user.Save(). +// --------------------------------------------------------------------------- + +describe('C# async await constructor binding resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-async-binding'), + () => {}, + ); + }, 60000); + + it('detects User, UserService, and OrderService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('UserService'); + expect(classes).toContain('OrderService'); + }); + + it('detects competing Save methods on User and Order', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('Save'); + expect(methods).toContain('GetUserAsync'); + expect(methods).toContain('GetOrderAsync'); + }); + + it('resolves user.Save() after await to User#Save via return type inference', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessUser' && c.targetFilePath.includes('User.cs'), + ); + expect(userSave).toBeDefined(); + }); + + it('user.Save() does NOT resolve to Order#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessUser' && c.targetFilePath.includes('Order.cs'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves order.Save() after await to Order#Save via return type inference', () => { + const calls = getRelationships(result, 'CALLS'); + const orderSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessOrder' && c.targetFilePath.includes('Order.cs'), + ); + expect(orderSave).toBeDefined(); + }); + + it('order.Save() does NOT resolve to User#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessOrder' && c.targetFilePath.includes('User.cs'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Assignment chain propagation (Phase 4.3) +// --------------------------------------------------------------------------- + +describe('C# assignment chain propagation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a Save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves alias.Save() to User#Save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + // Positive: alias.Save() must resolve to User#Save + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessEntities' && c.targetFilePath.includes('User.cs'), + ); + expect(userSave).toBeDefined(); + }); + + it('alias.Save() does NOT resolve to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + // Negative: alias comes from User, so only one edge to User.cs + const wrongCall = calls.filter(c => + c.target === 'Save' && c.source === 'ProcessEntities' && c.targetFilePath.includes('User.cs'), + ); + expect(wrongCall.length).toBe(1); + }); + + it('resolves rAlias.Save() to Repo#Save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + // Positive: rAlias.Save() must resolve to Repo#Save + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessEntities' && c.targetFilePath.includes('Repo.cs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('each alias resolves to its own class, not the other', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessEntities' && c.targetFilePath.includes('User.cs'), + ); + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessEntities' && c.targetFilePath.includes('Repo.cs'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.targetFilePath).not.toBe(repoSave!.targetFilePath); + }); +}); + +// --------------------------------------------------------------------------- +// C# mixed declarations: assignment chain + is-pattern in the same file. +// Tests that the type guard in extractPendingAssignment correctly skips +// is_pattern_expression nodes while still handling local_declaration_statement. +// --------------------------------------------------------------------------- + +describe('C# assignment chain + is-pattern coexistence', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-mixed-decl-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a Save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves alias.Save() to User#Save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessWithChain' && c.targetFilePath?.includes('User.cs'), + ); + expect(userSave).toBeDefined(); + }); + + it('assignment chain alias does NOT resolve to Repo#Save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'Save' && c.source === 'ProcessWithChain' && c.targetFilePath?.includes('Repo.cs'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves u.Save() to User#Save via is-pattern binding', () => { + const calls = getRelationships(result, 'CALLS'); + const patternSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessWithPattern' && c.targetFilePath?.includes('User.cs'), + ); + expect(patternSave).toBeDefined(); + }); + + it('resolves alias.Save() to Repo#Save via Repo assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessRepoChain' && c.targetFilePath?.includes('Repo.cs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('Repo chain alias does NOT resolve to User#Save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'Save' && c.source === 'ProcessRepoChain' && c.targetFilePath?.includes('User.cs'), + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// C# is-pattern disambiguation: `if (obj is User user)` should bind user → User +// and resolve user.Save() to User#Save, NOT Repo#Save. +// Validates the Phase 5.2 is_pattern_expression extraction in extractDeclaration. +// --------------------------------------------------------------------------- + +describe('C# is-pattern type binding disambiguation (Phase 5.2)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-is-pattern'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a Save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() inside if (obj is User user) to User#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && + c.source === 'Process' && + c.targetFilePath?.includes('User.cs'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.Save() to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && + c.source === 'Process' && + c.targetFilePath?.includes('Repo.cs'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method calls: svc.GetUser().Save() +// Tests that C# chain call resolution correctly infers the intermediate +// receiver type from GetUser()'s return type and resolves Save() to User. +// --------------------------------------------------------------------------- + +describe('C# chained method call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, and UserService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects GetUser and Save methods', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('GetUser'); + expect(methods).toContain('Save'); + }); + + it('resolves svc.GetUser().Save() to User#Save via chain resolution', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && + c.source === 'ProcessUser' && + c.targetFilePath?.includes('User.cs'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.GetUser().Save() to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && + c.source === 'ProcessUser' && + c.targetFilePath?.includes('Repo.cs'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// C# var foreach Tier 1c: foreach (var user in users) with List<User> param +// --------------------------------------------------------------------------- + +describe('C# var foreach type resolution (Tier 1c)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-var-foreach'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with Save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('detects methods on both classes', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods.filter(m => m === 'Save').length).toBe(2); + expect(methods).toContain('ProcessUsers'); + expect(methods).toContain('ProcessRepos'); + }); + + it('resolves direct calls with explicit parameter types (u.Save, r.Save)', () => { + const calls = getRelationships(result, 'CALLS'); + const directUserSave = calls.find(c => + c.target === 'Save' && c.source === 'Direct' && c.targetFilePath?.includes('User.cs'), + ); + const directRepoSave = calls.find(c => + c.target === 'Save' && c.source === 'Direct' && c.targetFilePath?.includes('Repo.cs'), + ); + expect(directUserSave).toBeDefined(); + expect(directRepoSave).toBeDefined(); + }); + + it('resolves user.Save() in var foreach to User#Save via Tier 1c', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessUsers' && c.targetFilePath?.includes('User.cs'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.Save() in var foreach to Repo#Save via Tier 1c', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessRepos' && c.targetFilePath?.includes('Repo.cs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.Save() to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'Save' && c.source === 'ProcessUsers' && c.targetFilePath?.includes('Repo.cs'), + ); + expect(wrong).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// C# switch pattern: switch (obj) { case User user: user.Save(); } +// --------------------------------------------------------------------------- + +describe('C# switch pattern type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-switch-pattern'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.Save() via is-pattern to User#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'Models/User.cs'); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.Save() via switch case pattern to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'Models/Repo.cs'); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// C# Dictionary .Values foreach — member_access_expression resolution +// --------------------------------------------------------------------------- + +describe('C# Dictionary .Values foreach resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-dictionary-keys-values'), + () => {}, + ); + }, 60000); + + it('detects User class with Save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves user.Save() via Dictionary.Values to User#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessValues' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.Save() to Repo#Save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessValues' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// C# recursive_pattern: obj is User { Name: "Alice" } u — Phase 6.1 +// --------------------------------------------------------------------------- + +describe('C# recursive_pattern type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-recursive-pattern'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with Save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves u.Save() via recursive_pattern is-expression to User#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves r.Save() via recursive_pattern switch expression to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && c.targetFilePath?.includes('Repo'), + ); + expect(repoSave).toBeDefined(); + }); + + it('resolves exactly one Save call per target class (no cross-resolution)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save' && c.source === 'ProcessWithRecursivePattern'); + const toUser = saveCalls.filter(c => c.targetFilePath?.includes('User')); + const toRepo = saveCalls.filter(c => c.targetFilePath?.includes('Repo')); + // u.Save() → User#Save only, r.Save() → Repo#Save only + expect(toUser.length).toBe(1); + expect(toRepo.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// C# nested member access with container property: this.data.Values +// --------------------------------------------------------------------------- + +describe('C# nested member access foreach (this.data.Values)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-nested-member-foreach'), + () => {}, + ); + }, 60000); + + it('detects User class with Save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves user.Save() via this.data.Values to User#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessValues' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.Save() to Repo#Save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'ProcessValues' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution (1-level) +// --------------------------------------------------------------------------- + +describe('Field type resolution (C#)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, Service, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'Service', 'User']); + }); + + it('detects Property nodes for C# properties', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('Address'); + expect(properties).toContain('Name'); + expect(properties).toContain('City'); + }); + + it('emits HAS_PROPERTY edges linking properties to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + expect(edgeSet(propEdges)).toContain('User → Address'); + expect(edgeSet(propEdges)).toContain('User → Name'); + expect(edgeSet(propEdges)).toContain('Address → City'); + }); + + it('resolves user.Address.Save() → Address#Save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'Save'); + const addressSave = saveCalls.find( + e => e.source === 'ProcessUser' && e.targetFilePath.includes('Models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8A: Deep field chain resolution (3-level) +// --------------------------------------------------------------------------- + +describe('Deep field chain resolution (C#)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-deep-field-chain'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, City, Service, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'City', 'Service', 'User']); + }); + + it('detects Property nodes for C# properties', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('Address'); + expect(properties).toContain('City'); + expect(properties).toContain('ZipCode'); + }); + + it('emits HAS_PROPERTY edges for nested type chain', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → Address'); + expect(edgeSet(propEdges)).toContain('Address → City'); + expect(edgeSet(propEdges)).toContain('City → ZipCode'); + }); + + it('resolves 2-level chain: user.Address.Save() → Address#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'Save' && e.source === 'ProcessUser'); + const addressSave = saveCalls.find(e => e.targetFilePath.includes('Models')); + expect(addressSave).toBeDefined(); + }); + + it('resolves 3-level chain: user.Address.City.GetName() → City#GetName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'GetName' && e.source === 'ProcessUser'); + const cityGetName = getNameCalls.find(e => e.targetFilePath.includes('Models')); + expect(cityGetName).toBeDefined(); + }); +}); + +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (C#)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'csharp-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for field assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(2); + const fieldNames = writes.map(e => e.target); + expect(fieldNames).toContain('Name'); + expect(fieldNames).toContain('Address'); + const sources = writes.map(e => e.source); + expect(sources).toContain('UpdateUser'); + }); + + it('write ACCESSES edges have confidence 1.0', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + for (const edge of writes) { + expect(edge.rel.confidence).toBe(1.0); + } + }); +}); diff --git a/gitnexus/test/integration/resolvers/go.test.ts b/gitnexus/test/integration/resolvers/go.test.ts new file mode 100644 index 0000000000..a1ba00c13a --- /dev/null +++ b/gitnexus/test/integration/resolvers/go.test.ts @@ -0,0 +1,1101 @@ +/** + * Go: package imports + cross-package calls + ambiguous struct disambiguation + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: package imports + cross-package calls (exercises PackageMap) +// --------------------------------------------------------------------------- + +describe('Go package import & call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-pkg'), + () => {}, + ); + }, 60000); + + it('detects exactly 2 structs and 1 interface', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['Admin', 'User']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['Repository']); + }); + + it('detects exactly 5 functions', () => { + expect(getNodesByLabel(result, 'Function')).toEqual([ + 'Authenticate', 'NewAdmin', 'NewUser', 'ValidateToken', 'main', + ]); + }); + + it('emits exactly 7 CALLS edges (5 function + 2 struct literal)', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(7); + expect(edgeSet(calls)).toEqual([ + 'Authenticate → NewUser', + 'NewAdmin → Admin', + 'NewAdmin → NewUser', + 'NewUser → User', + 'main → Authenticate', + 'main → NewAdmin', + 'main → NewUser', + ]); + }); + + it('resolves exactly 7 IMPORTS edges across Go packages', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(7); + expect(edgeSet(imports)).toEqual([ + 'main.go → admin.go', + 'main.go → repository.go', + 'main.go → service.go', + 'main.go → user.go', + 'service.go → admin.go', + 'service.go → repository.go', + 'service.go → user.go', + ]); + }); + + it('emits exactly 1 EXTENDS edge for struct embedding: Admin → User', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('Admin'); + expect(extends_[0].target).toBe('User'); + }); + + it('does not emit IMPLEMENTS edges (Go uses structural typing)', () => { + expect(getRelationships(result, 'IMPLEMENTS').length).toBe(0); + }); + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: Handler struct in two packages, package import disambiguates +// --------------------------------------------------------------------------- + +describe('Go ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler structs in separate packages', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(`${n.properties.name}@${n.properties.filePath}`); + }); + const handlers = structs.filter(s => s.startsWith('Handler@')); + expect(handlers.length).toBe(2); + expect(handlers.some(h => h.includes('internal/models/'))).toBe(true); + expect(handlers.some(h => h.includes('internal/other/'))).toBe(true); + }); + + it('import resolves to internal/models/handler.go (not internal/other/)', () => { + const imports = getRelationships(result, 'IMPORTS'); + const modelsImport = imports.find(e => e.targetFilePath.includes('models')); + expect(modelsImport).toBeDefined(); + expect(modelsImport!.targetFilePath).toBe('internal/models/handler.go'); + }); + + it('no import edge to internal/other/', () => { + const imports = getRelationships(result, 'IMPORTS'); + for (const imp of imports) { + expect(imp.targetFilePath).not.toMatch(/internal\/other\//); + } + }); +}); + +describe('Go call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-calls'), + () => {}, + ); + }, 60000); + + it('resolves main → WriteAudit to internal/onearg/log.go via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('main'); + expect(calls[0].target).toBe('WriteAudit'); + expect(calls[0].targetFilePath).toBe('internal/onearg/log.go'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.Method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('Go member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves processUser → Save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + expect(saveCall!.targetFilePath).toBe('models/user.go'); + }); + + it('detects User struct and Save method', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(n.properties.name); + }); + expect(structs).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('Save'); + }); +}); + +// --------------------------------------------------------------------------- +// Struct literal resolution: User{...} resolves to Struct node +// --------------------------------------------------------------------------- + +describe('Go struct literal resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-struct-literals'), + () => {}, + ); + }, 60000); + + it('resolves User{...} as a CALLS edge to the User struct', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.source).toBe('processUser'); + expect(ctorCall!.targetLabel).toBe('Struct'); + expect(ctorCall!.targetFilePath).toBe('user.go'); + }); + + it('also resolves user.Save() as a member call', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + }); + + it('detects User struct, Save method, and processUser function', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(n.properties.name); + }); + expect(structs).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('Save'); + expect(getNodesByLabel(result, 'Function')).toContain('processUser'); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed variables disambiguate same-named methods +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// Multi-assignment: user, repo := User{}, Repo{} — both sides captured in TypeEnv +// --------------------------------------------------------------------------- + +describe('Go multi-assignment short var declaration', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-multi-assign'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with their methods', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['Repo', 'User']); + expect(getNodesByLabel(result, 'Method')).toEqual(['Persist', 'Save']); + }); + + it('resolves both struct literals in multi-assignment: User{} and Repo{}', () => { + const calls = getRelationships(result, 'CALLS'); + const structCalls = calls.filter(c => c.targetLabel === 'Struct'); + expect(edgeSet(structCalls)).toEqual([ + 'process → Repo', + 'process → User', + ]); + }); + + it('resolves user.Save() to User.Save and repo.Persist() to Repo.Persist via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save'); + const cloneCall = calls.find(c => c.target === 'Persist'); + + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('process'); + expect(saveCall!.targetFilePath).toBe('models.go'); + + expect(cloneCall).toBeDefined(); + expect(cloneCall!.source).toBe('process'); + expect(cloneCall!.targetFilePath).toBe('models.go'); + }); +}); + +describe('Go receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, both with Save methods', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(n.properties.name); + }); + expect(structs).toContain('User'); + expect(structs).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() to User.Save and repo.Save() to Repo.Save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'models/user.go'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'models/repo.go'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + expect(repoSave!.source).toBe('processEntities'); + }); +}); + +// --------------------------------------------------------------------------- +// Variadic resolution: ...interface{} doesn't get filtered by arity +// --------------------------------------------------------------------------- + +describe('Go variadic call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-variadic-resolution'), + () => {}, + ); + }, 60000); + + it('resolves 3-arg call to variadic func Entry(...interface{}) in logger.go', () => { + const calls = getRelationships(result, 'CALLS'); + const logCall = calls.find(c => c.target === 'Entry'); + expect(logCall).toBeDefined(); + expect(logCall!.source).toBe('main'); + expect(logCall!.targetFilePath).toBe('internal/logger/logger.go'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: unqualified call resolves to local function, not imported package +// --------------------------------------------------------------------------- + +describe('Go local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves Save("test") to local Save in main.go, not utils.go', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save' && c.source === 'main'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('cmd/main.go'); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: user := models.User{}; user.Save() +// Go composite literal constructor pattern (no explicit type annotations) +// --------------------------------------------------------------------------- + +describe('Go constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, both with Save methods', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() to models/user.go via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models/user.go'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.Save() to models/repo.go via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models/repo.go'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 Save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Pointer-constructor-inferred type resolution: user := &models.User{...}; user.Save() +// Go address-of composite literal constructor pattern (no explicit type annotations) +// --------------------------------------------------------------------------- + +describe('Go pointer-constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-pointer-constructor-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, both with Save methods', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() to models/user.go via &User{} pointer-constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models/user.go'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('process'); + }); + + it('resolves repo.Save() to models/repo.go via &Repo{} pointer-constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models/repo.go'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('process'); + }); + + it('emits exactly 2 Save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Parent resolution: struct embedding emits EXTENDS +// --------------------------------------------------------------------------- + +describe('Go parent resolution (struct embedding)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User structs', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['BaseModel', 'User']); + }); + + it('emits EXTENDS edge: User → BaseModel (struct embedding)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); +}); + +// --------------------------------------------------------------------------- +// Go new() builtin type inference: user := new(User); user.Save() +// --------------------------------------------------------------------------- + +describe('Go new() builtin type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-new-builtin'), + () => {}, + ); + }, 60000); + + it('resolves user.Save() via new(User) inference', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models.go'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + }); + + it('resolves user.Greet() via new(User) inference', () => { + const calls = getRelationships(result, 'CALLS'); + const greetCall = calls.find(c => c.target === 'Greet' && c.targetFilePath === 'models.go'); + expect(greetCall).toBeDefined(); + expect(greetCall!.source).toBe('main'); + }); +}); + +// --------------------------------------------------------------------------- +// Go make() builtin type inference: sl := make([]User, 0); sl[0].Save() +// --------------------------------------------------------------------------- + +describe('Go make() builtin type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-make-builtin'), + () => {}, + ); + }, 60000); + + it('resolves sl[0].Save() via make([]User, 0) slice inference', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models.go'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + }); + + it('resolves m["key"].Greet() via make(map[string]User) map inference', () => { + const calls = getRelationships(result, 'CALLS'); + const greetCall = calls.find(c => c.target === 'Greet' && c.targetFilePath === 'models.go'); + expect(greetCall).toBeDefined(); + expect(greetCall!.source).toBe('main'); + }); +}); + +// --------------------------------------------------------------------------- +// Go type assertion inference: user := s.(User); user.Save() +// --------------------------------------------------------------------------- + +describe('Go type assertion type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-type-assertion'), + () => {}, + ); + }, 60000); + + it('resolves user.Save() via type assertion s.(User)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models.go'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('process'); + }); + + it('resolves user.Greet() via type assertion s.(User)', () => { + const calls = getRelationships(result, 'CALLS'); + const greetCall = calls.find(c => c.target === 'Greet' && c.targetFilePath === 'models.go'); + expect(greetCall).toBeDefined(); + expect(greetCall!.source).toBe('process'); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: user := GetUser("alice"); user.Save() +// Go now has a CONSTRUCTOR_BINDING_SCANNER for short_var_declaration, so +// return type inference works end-to-end for `user := GetUser()`. +// --------------------------------------------------------------------------- + +describe('Go return type inference via explicit function return type', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-return-type-inference'), + () => {}, + ); + }, 60000); + + it('detects GetUser, GetRepo, and competing Save methods', () => { + const allSymbols = [...getNodesByLabel(result, 'Function'), ...getNodesByLabel(result, 'Method')]; + expect(allSymbols).toContain('GetUser'); + expect(allSymbols).toContain('GetRepo'); + const saveMethods = allSymbols.filter(s => s === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() to models/user.go via return type of GetUser()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'Save' && c.source === 'processUser' && c.targetFilePath.includes('user.go') + ); + expect(saveCall).toBeDefined(); + }); + + it('user.Save() does NOT resolve to models/repo.go (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'processUser' && c.targetFilePath.includes('repo.go') + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves repo.Save() to models/repo.go via return type of GetRepo()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'Save' && c.source === 'processRepo' && c.targetFilePath.includes('repo.go') + ); + expect(saveCall).toBeDefined(); + }); + + it('repo.Save() does NOT resolve to models/user.go (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'processRepo' && c.targetFilePath.includes('user.go') + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves user.Save() via cross-package factory call models.NewUser()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'Save' && c.source === 'processUserCrossPackage' && c.targetFilePath.includes('user.go') + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Go multi-return factory inference: user, err := NewUser("alice"); user.Save() +// --------------------------------------------------------------------------- + +describe('Go multi-return factory type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-multi-return-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with competing Save methods', () => { + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() to models/user.go via multi-return inference (user, err := NewUser())', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'processUser' && c.targetFilePath.includes('user.go') + ); + expect(userSave).toBeDefined(); + }); + + it('user.Save() does NOT resolve to models/repo.go', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'processUser' && c.targetFilePath.includes('repo.go') + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves repo.Save() to models/repo.go via blank discard (repo, _ := NewRepo())', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'processRepo' && c.targetFilePath.includes('repo.go') + ); + expect(repoSave).toBeDefined(); + }); + + it('repo.Save() does NOT resolve to models/user.go', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'processRepo' && c.targetFilePath.includes('user.go') + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable receiver: var user *models.User = findUser(); user.Save() +// Go pointer types (*User) — extractSimpleTypeName strips pointer prefix. +// --------------------------------------------------------------------------- + +describe('Go nullable receiver resolution (pointer types)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, both with Save methods', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.Save() to User.Save via pointer receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models/user.go'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.Save() to Repo.Save via pointer receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'Save' && c.targetFilePath === 'models/repo.go'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('user.Save() does NOT resolve to Repo.Save (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save' && c.source === 'processEntities'); + expect(saveCalls.filter(c => c.targetFilePath === 'models/user.go').length).toBe(1); + expect(saveCalls.filter(c => c.targetFilePath === 'models/repo.go').length).toBe(1); + }); + + it('emits exactly 2 Save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'Save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Assignment chain propagation (Phase 4.3) +// --------------------------------------------------------------------------- + +describe('Go assignment chain propagation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs each with a Save method', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'Save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves alias.Save() to User#Save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + // Positive: alias.Save() must resolve to User#Save + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'processEntities' && c.targetFilePath.includes('user.go'), + ); + expect(userSave).toBeDefined(); + }); + + it('alias.Save() does NOT resolve to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + // Negative: alias comes from User, so only one edge to user.go + const wrongCall = calls.filter(c => + c.target === 'Save' && c.source === 'processEntities' && c.targetFilePath.includes('user.go'), + ); + expect(wrongCall.length).toBe(1); + }); + + it('resolves rAlias.Save() to Repo#Save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + // Positive: rAlias.Save() must resolve to Repo#Save + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'processEntities' && c.targetFilePath.includes('repo.go'), + ); + expect(repoSave).toBeDefined(); + }); + + it('each alias resolves to its own struct, not the other', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'processEntities' && c.targetFilePath.includes('user.go'), + ); + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'processEntities' && c.targetFilePath.includes('repo.go'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.targetFilePath).not.toBe(repoSave!.targetFilePath); + }); + + // --- var form assignment chain --- + + it('resolves var alias.Save() to User via var assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'processWithVar' && c.targetFilePath.includes('user.go'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves var rAlias.Save() to Repo via var assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'processWithVar' && c.targetFilePath.includes('repo.go'), + ); + expect(repoSave).toBeDefined(); + }); + + it('var alias.Save() does NOT resolve to Repo (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const userSaves = calls.filter(c => + c.target === 'Save' && c.source === 'processWithVar' && c.targetFilePath.includes('user.go'), + ); + expect(userSaves.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method calls: svc.GetUser().Save() +// Tests that Go chain call resolution correctly infers the intermediate +// receiver type from GetUser()'s return type and resolves Save() to User. +// --------------------------------------------------------------------------- + +describe('Go chained method call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User, Repo structs and UserService', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + expect(getNodesByLabel(result, 'Struct')).toContain('UserService'); + }); + + it('detects GetUser and Save symbols', () => { + const allSymbols = [...getNodesByLabel(result, 'Function'), ...getNodesByLabel(result, 'Method')]; + expect(allSymbols).toContain('GetUser'); + expect(allSymbols).toContain('Save'); + }); + + it('resolves svc.GetUser().Save() to User#Save via chain resolution', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && + c.source === 'processUser' && + c.targetFilePath?.includes('user.go'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.GetUser().Save() to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && + c.source === 'processUser' && + c.targetFilePath?.includes('repo.go'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Go map range: for _, user := range userMap where map[string]User +// --------------------------------------------------------------------------- + +describe('Go map range type resolution (Tier 1c)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-map-range'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with Save methods in separate files', () => { + const structs = getNodesByLabel(result, 'Struct'); + expect(structs).toContain('User'); + expect(structs).toContain('Repo'); + const methods = getNodesByLabel(result, 'Method'); + expect(methods.filter(m => m === 'Save').length).toBe(2); + }); + + it('resolves user.Save() in map range to User#Save via map_type value', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'processMap' && c.targetFilePath?.includes('user.go'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.Save() to Repo#Save (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'processMap' && c.targetFilePath?.includes('repo.go'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Go for-loop with call_expression iterable: for _, user := range GetUsers() +// Phase 7.3: call_expression iterable resolution via ReturnTypeLookup +// --------------------------------------------------------------------------- + +describe('Go for-loop call_expression iterable resolution (Phase 7.3)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-for-call-expr'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with competing Save methods', () => { + const structs = getNodesByLabel(result, 'Struct'); + expect(structs).toContain('User'); + expect(structs).toContain('Repo'); + const methods = getNodesByLabel(result, 'Method'); + expect(methods.filter(m => m === 'Save').length).toBe(2); + }); + + it('resolves user.Save() in range GetUsers() to User#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'Save' && c.source === 'processUsers' && c.targetFilePath?.includes('user.go'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.Save() in range GetRepos() to Repo#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'Save' && c.source === 'processRepos' && c.targetFilePath?.includes('repo.go'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT resolve user.Save() to Repo#Save (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'processUsers' && c.targetFilePath?.includes('repo.go'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('does NOT resolve repo.Save() to User#Save (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'Save' && c.source === 'processRepos' && c.targetFilePath?.includes('user.go'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution (1-level) +// --------------------------------------------------------------------------- + +describe('Field type resolution (Go)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-field-types'), + () => {}, + ); + }, 60000); + + it('detects structs: Address, User', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['Address', 'User']); + }); + + it('detects Property nodes for Go struct fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('Address'); + expect(properties).toContain('Name'); + expect(properties).toContain('City'); + }); + + it('emits HAS_PROPERTY edges linking struct fields to structs', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + expect(edgeSet(propEdges)).toContain('User → Name'); + expect(edgeSet(propEdges)).toContain('User → Address'); + expect(edgeSet(propEdges)).toContain('Address → City'); + }); + + it('resolves user.Address.Save() → Address#Save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'Save'); + const addressSave = saveCalls.find( + e => e.source === 'processUser' && e.targetFilePath.includes('models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8A: Deep field chain resolution (3-level) +// --------------------------------------------------------------------------- + +describe('Deep field chain resolution (Go)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-deep-field-chain'), + () => {}, + ); + }, 60000); + + it('detects structs: Address, City, User', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['Address', 'City', 'User']); + }); + + it('detects Property nodes for Go struct fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('Address'); + expect(properties).toContain('City'); + expect(properties).toContain('ZipCode'); + }); + + it('emits HAS_PROPERTY edges for nested type chain', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(5); + expect(edgeSet(propEdges)).toContain('User → Name'); + expect(edgeSet(propEdges)).toContain('User → Address'); + expect(edgeSet(propEdges)).toContain('Address → City'); + expect(edgeSet(propEdges)).toContain('Address → Street'); + expect(edgeSet(propEdges)).toContain('City → ZipCode'); + }); + + it('resolves 2-level chain: user.Address.Save() → Address#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'Save' && e.source === 'processUser'); + const addressSave = saveCalls.find(e => e.targetFilePath.includes('models')); + expect(addressSave).toBeDefined(); + }); + + it('resolves 3-level chain: user.Address.City.GetName() → City#GetName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'GetName' && e.source === 'processUser'); + const cityGetName = getNameCalls.find(e => e.targetFilePath.includes('models')); + expect(cityGetName).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Mixed field+call chain resolution (Go) +// --------------------------------------------------------------------------- + +describe('Mixed field+call chain resolution (Go)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-mixed-chain'), + () => {}, + ); + }, 60000); + + it('detects structs: Address, City, User, UserService', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['Address', 'City', 'User', 'UserService']); + }); + + it('detects Property nodes for mixed-chain fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('City'); + expect(properties).toContain('Address'); + }); + + it('resolves call→field chain: svc.GetUser().Address.Save() → Address#Save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'Save' && e.source === 'processWithService'); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('models'); + }); + + it('resolves field→call chain: user.GetAddress().City.GetName() → City#GetName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'GetName' && e.source === 'processWithUser'); + expect(getNameCalls.length).toBe(1); + expect(getNameCalls[0].targetFilePath).toContain('models'); + }); +}); + +// --------------------------------------------------------------------------- +// ACCESSES write edges from assignment statements +// --------------------------------------------------------------------------- + +describe('Write access tracking (Go)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'go-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for field assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(2); + const nameWrite = writes.find(e => e.target === 'Name'); + const addressWrite = writes.find(e => e.target === 'Address'); + expect(nameWrite).toBeDefined(); + expect(nameWrite!.source).toBe('updateUser'); + expect(addressWrite).toBeDefined(); + expect(addressWrite!.source).toBe('updateUser'); + }); +}); diff --git a/gitnexus/test/integration/resolvers/helpers.ts b/gitnexus/test/integration/resolvers/helpers.ts new file mode 100644 index 0000000000..aad26034cd --- /dev/null +++ b/gitnexus/test/integration/resolvers/helpers.ts @@ -0,0 +1,57 @@ +/** + * Shared test helpers for language resolution integration tests. + */ +import path from 'path'; +import { runPipelineFromRepo } from '../../../src/core/ingestion/pipeline.js'; +import type { PipelineOptions } from '../../../src/core/ingestion/pipeline.js'; +import type { PipelineResult } from '../../../src/types/pipeline.js'; +import type { GraphRelationship } from '../../../src/core/graph/types.js'; + +export const FIXTURES = path.resolve(__dirname, '..', '..', 'fixtures', 'lang-resolution'); + +export type RelEdge = { + source: string; + target: string; + sourceLabel: string; + targetLabel: string; + sourceFilePath: string; + targetFilePath: string; + rel: GraphRelationship; +}; + +export function getRelationships(result: PipelineResult, type: string): RelEdge[] { + const edges: RelEdge[] = []; + for (const rel of result.graph.iterRelationships()) { + if (rel.type === type) { + const sourceNode = result.graph.getNode(rel.sourceId); + const targetNode = result.graph.getNode(rel.targetId); + edges.push({ + source: sourceNode?.properties.name ?? rel.sourceId, + target: targetNode?.properties.name ?? rel.targetId, + sourceLabel: sourceNode?.label ?? 'unknown', + targetLabel: targetNode?.label ?? 'unknown', + sourceFilePath: sourceNode?.properties.filePath ?? '', + targetFilePath: targetNode?.properties.filePath ?? '', + rel, + }); + } + } + return edges; +} + +export function getNodesByLabel(result: PipelineResult, label: string): string[] { + const names: string[] = []; + result.graph.forEachNode(n => { + if (n.label === label) names.push(n.properties.name); + }); + return names.sort(); +} + +export function edgeSet(edges: Array<{ source: string; target: string }>): string[] { + return edges.map(e => `${e.source} → ${e.target}`).sort(); +} + +// Tests can pass { skipGraphPhases: true } as third arg for faster runs +// (skips MRO, community detection, and process extraction). +export { runPipelineFromRepo }; +export type { PipelineOptions, PipelineResult }; diff --git a/gitnexus/test/integration/resolvers/java.test.ts b/gitnexus/test/integration/resolvers/java.test.ts new file mode 100644 index 0000000000..b19ca0d638 --- /dev/null +++ b/gitnexus/test/integration/resolvers/java.test.ts @@ -0,0 +1,1234 @@ +/** + * Java: class extends + implements multiple interfaces + ambiguous package disambiguation + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: class extends + implements multiple interfaces +// --------------------------------------------------------------------------- + +describe('Java heritage resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-heritage'), + () => {}, + ); + }, 60000); + + it('detects exactly 3 classes and 2 interfaces', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User', 'UserService']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['Serializable', 'Validatable']); + }); + + it('emits exactly 1 EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits exactly 2 IMPLEMENTS edges: User → Serializable, User → Validatable', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(2); + expect(edgeSet(implements_)).toEqual([ + 'User → Serializable', + 'User → Validatable', + ]); + }); + + it('resolves exactly 4 IMPORTS edges', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(4); + expect(edgeSet(imports)).toEqual([ + 'User.java → Serializable.java', + 'User.java → Validatable.java', + 'UserService.java → Serializable.java', + 'UserService.java → User.java', + ]); + }); + + it('does not emit EXTENDS edges to interfaces', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.some(e => e.target === 'Serializable')).toBe(false); + expect(extends_.some(e => e.target === 'Validatable')).toBe(false); + }); + + it('emits exactly 2 CALLS edges', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(2); + expect(edgeSet(calls)).toEqual([ + 'processUser → save', + 'processUser → validate', + ]); + }); + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: Handler + Processor in two packages, imports disambiguate +// --------------------------------------------------------------------------- + +describe('Java ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler classes and 2 Processor interfaces', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes.filter(n => n === 'Handler').length).toBe(2); + expect(classes).toContain('UserHandler'); + const ifaces = getNodesByLabel(result, 'Interface'); + expect(ifaces.filter(n => n === 'Processor').length).toBe(2); + }); + + it('resolves EXTENDS to models/Handler (not other/Handler)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('UserHandler'); + expect(extends_[0].target).toBe('Handler'); + expect(extends_[0].targetFilePath).toBe('models/Handler.java'); + }); + + it('resolves IMPLEMENTS to models/Processor (not other/Processor)', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('UserHandler'); + expect(implements_[0].target).toBe('Processor'); + expect(implements_[0].targetFilePath).toBe('models/Processor.java'); + }); + + it('import edges point to models/ not other/', () => { + const imports = getRelationships(result, 'IMPORTS'); + const targets = imports.map(e => e.target).sort(); + expect(targets).toContain('Handler.java'); + expect(targets).toContain('Processor.java'); + for (const imp of imports) { + expect(imp.targetFilePath).toMatch(/^models\//); + } + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +describe('Java call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-calls'), + () => {}, + ); + }, 60000); + + it('resolves processUser → writeAudit to util/OneArg.java via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('processUser'); + expect(calls[0].target).toBe('writeAudit'); + expect(calls[0].targetFilePath).toBe('util/OneArg.java'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('Java member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves processUser → save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + expect(saveCall!.targetFilePath).toBe('models/User.java'); + }); + + it('detects User class and save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('emits HAS_METHOD edge from User to save', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'User' && e.target === 'save'); + expect(edge).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor resolution: new Foo() resolves to Constructor/Class +// --------------------------------------------------------------------------- + +describe('Java constructor-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-constructor-calls'), + () => {}, + ); + }, 60000); + + it('resolves new User() as a CALLS edge to the User constructor', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.source).toBe('processUser'); + // Java has explicit constructor_declaration → Constructor node + expect(ctorCall!.targetLabel).toBe('Constructor'); + expect(ctorCall!.targetFilePath).toBe('models/User.java'); + }); + + it('also resolves user.save() as a member call', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + }); + + it('detects User class, User constructor, save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Constructor')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed variables disambiguate same-named methods +// --------------------------------------------------------------------------- + +describe('Java receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User.save and repo.save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'models/User.java'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'models/Repo.java'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('resolves constructor calls for both User and Repo', () => { + const calls = getRelationships(result, 'CALLS'); + const userCtor = calls.find(c => c.target === 'User'); + const repoCtor = calls.find(c => c.target === 'Repo'); + expect(userCtor).toBeDefined(); + expect(repoCtor).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Named import disambiguation: two User classes, import resolves to correct one +// --------------------------------------------------------------------------- + +describe('Java named import disambiguation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-named-imports'), + () => {}, + ); + }, 60000); + + it('detects two User classes in different packages', () => { + const users = getNodesByLabel(result, 'Class').filter(n => n === 'User'); + expect(users.length).toBe(2); + }); + + it('resolves user.save() to com/example/models/User.java via named import', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('run'); + expect(saveCall!.targetFilePath).toBe('com/example/models/User.java'); + }); + + it('resolves new User() to com/example/models/User.java, not other/', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User' && c.source === 'run'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.targetFilePath).toBe('com/example/models/User.java'); + }); +}); + +// --------------------------------------------------------------------------- +// Variadic resolution: String... doesn't get filtered by arity +// --------------------------------------------------------------------------- + +describe('Java variadic call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-variadic-resolution'), + () => {}, + ); + }, 60000); + + it('resolves 3-arg call to varargs method record(String...) in Logger.java', () => { + const calls = getRelationships(result, 'CALLS'); + const logCall = calls.find(c => c.target === 'record'); + expect(logCall).toBeDefined(); + expect(logCall!.source).toBe('run'); + expect(logCall!.targetFilePath).toBe('com/example/util/Logger.java'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('Java local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves run → save to same-file definition, not the imported one', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'run'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/main/java/com/example/app/Main.java'); + }); + + it('does NOT resolve save to Logger.java', () => { + const calls = getRelationships(result, 'CALLS'); + const saveToUtils = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/main/java/com/example/utils/Logger.java'); + expect(saveToUtils).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: var user = new User(); user.save() +// Java 10+ local variable type inference (no explicit type annotations) +// --------------------------------------------------------------------------- + +describe('Java constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to models/User.java via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/User.java'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.save() to models/Repo.java via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/Repo.java'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// For-each loop element typing: for (User user : users) user.save() +// Java: explicit type in enhanced_for_statement binds loop variable +// --------------------------------------------------------------------------- + +describe('Java for-each loop element type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-foreach'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() in for-each to User#save (not Repo#save)', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/User.java'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.save() in for-each to Repo#save (not User#save)', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/Repo.java'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// this.save() resolves to enclosing class's own save method +// --------------------------------------------------------------------------- + +describe('Java this resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves this.save() inside User.process to User.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/models/User.java'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS + IMPLEMENTS edges +// --------------------------------------------------------------------------- + +describe('Java parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes plus Serializable interface', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['Serializable']); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits IMPLEMENTS edge: User → Serializable', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('User'); + expect(implements_[0].target).toBe('Serializable'); + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +// --------------------------------------------------------------------------- +// super.save() resolves to parent class's save method +// --------------------------------------------------------------------------- + +describe('Java super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-super-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('resolves super.save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const superSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'src/models/BaseModel.java'); + expect(superSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/models/Repo.java'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// super.save() resolves to generic parent class's save method +// --------------------------------------------------------------------------- + +describe('Java generic parent super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-generic-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('resolves super.save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const superSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'src/models/BaseModel.java'); + expect(superSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/models/Repo.java'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: var user = svc.getUser("alice"); user.save() +// Java's CONSTRUCTOR_BINDING_SCANNER handles `var` declarations with +// method_invocation values, enabling end-to-end return type inference. +// --------------------------------------------------------------------------- + +describe('Java return type inference via explicit method return type', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-return-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and UserService classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + }); + + it('detects save and getUser methods', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('save'); + expect(methods).toContain('getUser'); + }); + + it('resolves user.save() to User#save via return type of getUser(): User', () => { + // Java's CONSTRUCTOR_BINDING_SCANNER binds `var user = svc.getUser()` to the + // return type of getUser (User), so the subsequent user.save() call resolves + // to User#save rather than an unresolved target. + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('models') + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable receiver: Java uses explicit type annotations (User user = findUser()) +// Tests that regular typed receiver resolution works with competing save() methods +// when the variable is assigned from a factory method returning the same type. +// Note: Java Optional<User> stores just "Optional" in TypeEnv (generics stripped), +// so this test uses plain typed variables to validate receiver disambiguation. +// --------------------------------------------------------------------------- + +describe('Java nullable receiver resolution (typed factory return)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/User.java'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/Repo.java'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('user.save() does NOT resolve to Repo.save (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save' && c.source === 'processEntities'); + // Each save() call should resolve to exactly one target file + expect(saveCalls.filter(c => c.targetFilePath === 'models/User.java').length).toBe(1); + expect(saveCalls.filter(c => c.targetFilePath === 'models/Repo.java').length).toBe(1); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Assignment chain propagation (Phase 4.3) +// --------------------------------------------------------------------------- + +describe('Java assignment chain propagation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves alias.save() to User#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + // Positive: alias.save() must resolve to User#save + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('User.java'), + ); + expect(userSave).toBeDefined(); + }); + + it('alias.save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + // Negative: alias comes from User, so only one edge to User.java + const wrongCall = calls.filter(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('User.java'), + ); + expect(wrongCall.length).toBe(1); + }); + + it('resolves rAlias.save() to Repo#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + // Positive: rAlias.save() must resolve to Repo#save + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('Repo.java'), + ); + expect(repoSave).toBeDefined(); + }); + + it('each alias resolves to its own class, not the other', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('User.java'), + ); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('Repo.java'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.targetFilePath).not.toBe(repoSave!.targetFilePath); + }); +}); + +// --------------------------------------------------------------------------- +// Java Optional<User> receiver resolution — extractSimpleTypeName unwraps +// Optional<User> to "User" via NULLABLE_WRAPPER_TYPES, enabling receiver +// disambiguation when the declaration type is Optional<T>. +// --------------------------------------------------------------------------- + +describe('Java Optional<User> receiver resolution via wrapper unwrapping', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-optional-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User#save with Optional<User> in scope', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath?.includes('User.java'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() to Repo#save alongside Optional usage', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath?.includes('Repo.java'), + ); + expect(repoSave).toBeDefined(); + }); + + it('disambiguates user.save() and repo.save() to different files', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath?.includes('User.java'), + ); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath?.includes('Repo.java'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.targetFilePath).not.toBe(repoSave!.targetFilePath); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method call resolution: svc.getUser().save() +// The receiver of save() is a method_invocation (getUser()), not a simple identifier. +// Resolution must walk the chain: getUser() returns User, so save() → User#save. +// --------------------------------------------------------------------------- + +describe('Java chained method call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User, Repo and UserService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects save methods on both User and Repo', () => { + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('detects getUser method on UserService', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('getUser'); + }); + + it('resolves svc.getUser().save() to User#save, NOT Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath.includes('User.java'), + ); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath.includes('Repo.java'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Java 16+ instanceof pattern variable: `if (obj instanceof User user)` +// Phase 5.2: extractPatternBinding on instanceof_expression binds user → User. +// Disambiguation: User.save vs Repo.save — only User.save should be called. +// --------------------------------------------------------------------------- + +describe('Java instanceof pattern variable resolution (Phase 5.2)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-instanceof-pattern'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() inside if (obj instanceof User user) to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'process' && + c.targetFilePath.includes('User.java'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'process' && + c.targetFilePath.includes('Repo.java'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Enum static method calls: Status.fromCode(200) should resolve via +// class-as-receiver with Enum type included in the filter. +// --------------------------------------------------------------------------- + +describe('Java enum static method call resolution (Phase 5 review fix)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-enum-static-call'), + () => {}, + ); + }, 60000); + + it('detects Status as an Enum and App as a Class', () => { + expect(getNodesByLabel(result, 'Enum')).toContain('Status'); + expect(getNodesByLabel(result, 'Class')).toContain('App'); + }); + + it('detects fromCode and label methods on Status', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('fromCode'); + expect(methods).toContain('label'); + }); + + it('resolves Status.fromCode(200) to Status#fromCode via class-as-receiver', () => { + const calls = getRelationships(result, 'CALLS'); + const fromCodeCall = calls.find(c => + c.target === 'fromCode' && + c.source === 'process' && + c.targetFilePath?.includes('Status.java'), + ); + expect(fromCodeCall).toBeDefined(); + }); + + it('resolves s.label() to Status#label', () => { + const calls = getRelationships(result, 'CALLS'); + const labelCall = calls.find(c => + c.target === 'label' && + c.source === 'process' && + c.targetFilePath?.includes('Status.java'), + ); + expect(labelCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Java 21+ switch pattern matching: switch (obj) { case User user -> user.save(); } +// --------------------------------------------------------------------------- + +describe('Java switch pattern binding', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-switch-pattern'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() in switch case User to models/User.java', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processAny' && c.targetFilePath === 'models/User.java', + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in switch case Repo to models/Repo.java', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processAny' && c.targetFilePath === 'models/Repo.java', + ); + expect(repoSave).toBeDefined(); + }); + + it('resolves user.save() in handleUser switch case User to models/User.java', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'handleUser' && c.targetFilePath === 'models/User.java', + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT cross-resolve handleUser switch case User to Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'handleUser' && c.targetFilePath === 'models/Repo.java', + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Java Map .values() for-loop — method-aware type arg resolution +// --------------------------------------------------------------------------- + +describe('Java Map .values() for-loop resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-map-keys-values'), + () => {}, + ); + }, 60000); + + it('detects User class with save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves user.save() via Map.values() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processValues' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processValues' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves user.save() via List iteration to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processList' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Java enhanced for-loop with call_expression iterable: for (User user : getUsers()) +// Phase 7.3: call_expression iterable resolution via ReturnTypeLookup +// --------------------------------------------------------------------------- + +describe('Java foreach call_expression iterable resolution (Phase 7.3)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-foreach-call-expr'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() in foreach over User.getUsers() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('User.java'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in foreach over Repo.getRepos() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('Repo.java'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('Repo.java'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('does NOT resolve repo.save() to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('User.java'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution (1-level) +// --------------------------------------------------------------------------- + +describe('Field type resolution (Java)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, App, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'App', 'User']); + }); + + it('detects Property nodes for Java fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking properties to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('Address → city'); + }); + + it('resolves user.address.save() → Address#save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find( + e => e.source === 'processUser' && e.targetFilePath.includes('Address'), + ); + expect(addressSave).toBeDefined(); + }); + + it('emits ACCESSES read edge for user.address field access in chain', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const addressReads = accesses.filter(e => e.target === 'address' && e.rel.reason === 'read'); + expect(addressReads.length).toBe(1); + expect(addressReads[0].source).toBe('processUser'); + expect(addressReads[0].targetLabel).toBe('Property'); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8A: Deep field chain resolution (3-level) +// --------------------------------------------------------------------------- + +describe('Deep field chain resolution (Java)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-deep-field-chain'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, App, City, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'App', 'City', 'User']); + }); + + it('detects Property nodes for Java fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('city'); + expect(properties).toContain('zipCode'); + }); + + it('emits HAS_PROPERTY edges for nested type chain', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('Address → city'); + expect(edgeSet(propEdges)).toContain('City → zipCode'); + }); + + it('resolves 2-level chain: user.address.save() → Address#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'processUser'); + const addressSave = saveCalls.find(e => e.targetFilePath.includes('Address')); + expect(addressSave).toBeDefined(); + }); + + it('resolves 3-level chain: user.address.city.getName() → City#getName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'getName' && e.source === 'processUser'); + const cityGetName = getNameCalls.find(e => e.targetFilePath.includes('City')); + expect(cityGetName).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Mixed field+call chain resolution (Java) +// --------------------------------------------------------------------------- + +describe('Mixed field+call chain resolution (Java)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-mixed-chain'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, App, City, User, UserService', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'App', 'City', 'User', 'UserService']); + }); + + it('detects Property nodes for mixed-chain fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('city'); + expect(properties).toContain('address'); + }); + + it('resolves call→field chain: svc.getUser().address.save() → Address#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'processWithService'); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('Address'); + }); + + it('resolves field→call chain: user.getAddress().city.getName() → City#getName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'getName' && e.source === 'processWithUser'); + expect(getNameCalls.length).toBe(1); + expect(getNameCalls[0].targetFilePath).toContain('City'); + }); +}); + +// --------------------------------------------------------------------------- +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (Java)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'java-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for field assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(2); + const nameWrite = writes.find(e => e.target === 'name'); + const addressWrite = writes.find(e => e.target === 'address'); + expect(nameWrite).toBeDefined(); + expect(nameWrite!.source).toBe('updateUser'); + expect(addressWrite).toBeDefined(); + expect(addressWrite!.source).toBe('updateUser'); + }); +}); diff --git a/gitnexus/test/integration/resolvers/javascript.test.ts b/gitnexus/test/integration/resolvers/javascript.test.ts new file mode 100644 index 0000000000..58bbb54ecd --- /dev/null +++ b/gitnexus/test/integration/resolvers/javascript.test.ts @@ -0,0 +1,304 @@ +/** + * JavaScript: self/this resolution, parent resolution, super resolution + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// skipGraphPhases: verify pipeline works correctly when graph phases are skipped +// --------------------------------------------------------------------------- + +describe('Pipeline skipGraphPhases option', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'javascript-self-this-resolution'), + () => {}, + { skipGraphPhases: true }, + ); + }, 60000); + + it('produces graph nodes without community/process phases', () => { + expect(getNodesByLabel(result, 'Class').length).toBeGreaterThan(0); + }); + + it('still resolves CALLS edges correctly', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBeGreaterThan(0); + }); + + it('omits communityResult when skipGraphPhases is true', () => { + expect(result.communityResult).toBeUndefined(); + }); + + it('omits processResult when skipGraphPhases is true', () => { + expect(result.processResult).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// this.save() resolves to enclosing class's own save method +// --------------------------------------------------------------------------- + +describe('JavaScript this resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'javascript-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves this.save() inside User.process to User.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/models/User.js'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS edge +// --------------------------------------------------------------------------- + +describe('JavaScript parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'javascript-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('EXTENDS edge points to real graph node', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + const target = result.graph.getNode(extends_[0].rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe('BaseModel'); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable receiver: JSDoc @param {User | null} strips nullable via TypeEnv +// --------------------------------------------------------------------------- + +describe('JavaScript nullable receiver resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'js-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to src/user.js via nullable-stripped JSDoc type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.source === 'processEntities' && c.targetFilePath === 'src/user.js'); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() to src/repo.js via nullable-stripped JSDoc type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.source === 'processEntities' && c.targetFilePath === 'src/repo.js'); + expect(repoSave).toBeDefined(); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); + + it('each save() call resolves to a distinct file (no duplicates)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save' && c.source === 'processEntities'); + const files = saveCalls.map(c => c.targetFilePath).sort(); + expect(files).toEqual(['src/repo.js', 'src/user.js']); + }); +}); + +// --------------------------------------------------------------------------- +// super.save() resolves to parent class's save method +// --------------------------------------------------------------------------- + +describe('JavaScript super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'javascript-super-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(3); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('resolves super.save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const superSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'src/models/Base.js'); + expect(superSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/models/Repo.js'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method calls: svc.getUser().save() +// Tests that JavaScript chain call resolution correctly infers the intermediate +// receiver type from getUser()'s JSDoc @returns {User} and resolves save(). +// --------------------------------------------------------------------------- + +describe('JavaScript chained method call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'javascript-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, and UserService', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects getUser and save methods', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('getUser'); + expect(methods).toContain('save'); + }); + + it('resolves svc.getUser().save() to User#save via chain resolution', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath?.includes('user.js'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.getUser().save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath?.includes('repo.js'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution — class field_definition capture +// --------------------------------------------------------------------------- + +describe('Field type resolution (JavaScript)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'js-field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, Config, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'Config', 'User']); + }); + + it('detects Property nodes for JS class fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking fields to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(4); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('Address → city'); + expect(edgeSet(propEdges)).toContain('Config → DEFAULT'); + }); +}); + +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (JavaScript)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'js-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for field assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(2); + const fieldNames = writes.map(e => e.target); + expect(fieldNames).toContain('name'); + expect(fieldNames).toContain('address'); + const sources = writes.map(e => e.source); + expect(sources).toContain('updateUser'); + }); + + it('write ACCESSES edges have confidence 1.0', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + for (const edge of writes) { + expect(edge.rel.confidence).toBe(1.0); + } + }); +}); diff --git a/gitnexus/test/integration/resolvers/kotlin.test.ts b/gitnexus/test/integration/resolvers/kotlin.test.ts new file mode 100644 index 0000000000..a6866faca1 --- /dev/null +++ b/gitnexus/test/integration/resolvers/kotlin.test.ts @@ -0,0 +1,1397 @@ +/** + * Kotlin: data class extends + implements interfaces + ambiguous import disambiguation + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: data class extends + implements interfaces (delegation specifiers) +// --------------------------------------------------------------------------- + +describe('Kotlin heritage resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-heritage'), + () => {}, + ); + }, 60000); + + it('detects exactly 3 classes and 2 interfaces', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User', 'UserService']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['Serializable', 'Validatable']); + }); + + it('detects 6 functions (interface declarations + implementations + service)', () => { + expect(getNodesByLabel(result, 'Function')).toEqual([ + 'processUser', 'save', 'serialize', 'serialize', 'validate', 'validate', + ]); + }); + + it('emits exactly 1 EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits exactly 2 IMPLEMENTS edges via symbol table resolution', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(2); + expect(edgeSet(implements_)).toEqual([ + 'User → Serializable', + 'User → Validatable', + ]); + }); + + it('resolves exactly 4 IMPORTS edges (JVM-style package imports)', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(4); + expect(edgeSet(imports)).toEqual([ + 'User.kt → Serializable.kt', + 'User.kt → Validatable.kt', + 'UserService.kt → Serializable.kt', + 'UserService.kt → User.kt', + ]); + }); + + it('does not emit EXTENDS edges to interfaces', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.some(e => e.target === 'Serializable')).toBe(false); + expect(extends_.some(e => e.target === 'Validatable')).toBe(false); + }); + + it('resolves ambiguous validate() call through non-aliased import with import-resolved reason', () => { + const calls = getRelationships(result, 'CALLS'); + // validate is defined in both Validatable (interface) and User (override) → needs import scoping + const validateCall = calls.find(c => c.target === 'validate'); + expect(validateCall).toBeDefined(); + expect(validateCall!.source).toBe('processUser'); + expect(validateCall!.rel.reason).toBe('import-resolved'); + }); + + it('resolves unique save() call through non-aliased import', () => { + const calls = getRelationships(result, 'CALLS'); + // save is unique globally (only in BaseModel) → resolves as unique-global + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + }); + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); + + it('all heritage edges point to real graph nodes', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + const implements_ = getRelationships(result, 'IMPLEMENTS'); + + for (const edge of [...extends_, ...implements_]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: Handler + Runnable in two packages, explicit imports disambiguate +// --------------------------------------------------------------------------- + +describe('Kotlin ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler classes and 2 Runnable interfaces', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes.filter(n => n === 'Handler').length).toBe(2); + const ifaces = getNodesByLabel(result, 'Interface'); + expect(ifaces.filter(n => n === 'Runnable').length).toBe(2); + }); + + it('resolves EXTENDS to models/Handler.kt (not other/Handler.kt)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('UserHandler'); + expect(extends_[0].target).toBe('Handler'); + expect(extends_[0].targetFilePath).toBe('models/Handler.kt'); + }); + + it('resolves IMPLEMENTS to models/Runnable.kt (not other/Runnable.kt)', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('UserHandler'); + expect(implements_[0].target).toBe('Runnable'); + expect(implements_[0].targetFilePath).toBe('models/Runnable.kt'); + }); + + it('import edges point to models/ not other/', () => { + const imports = getRelationships(result, 'IMPORTS'); + for (const imp of imports) { + expect(imp.targetFilePath).toMatch(/^models\//); + } + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +describe('Kotlin call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-calls'), + () => {}, + ); + }, 60000); + + it('resolves processUser → writeAudit to util/OneArg.kt via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('processUser'); + expect(calls[0].target).toBe('writeAudit'); + expect(calls[0].targetFilePath).toBe('util/OneArg.kt'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('Kotlin member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves processUser → save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + expect(saveCall!.targetFilePath).toBe('models/User.kt'); + }); + + it('detects User class and save function (Kotlin fns are Function nodes)', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + // Kotlin tree-sitter captures all function_declaration as Function, including class methods + expect(getNodesByLabel(result, 'Function')).toContain('save'); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed variables disambiguate same-named methods +// --------------------------------------------------------------------------- + +describe('Kotlin receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save functions', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + // Kotlin tree-sitter captures all function_declaration as Function + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() to User.save and repo.save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'models/User.kt'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'models/Repo.kt'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + expect(repoSave!.source).toBe('processEntities'); + }); +}); + +// --------------------------------------------------------------------------- +// Alias import resolution: import com.example.User as U resolves U → User +// --------------------------------------------------------------------------- + +describe('Kotlin alias import resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-alias-imports'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with their methods', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + // Kotlin tree-sitter captures all function_declaration as Function, including class methods + expect(getNodesByLabel(result, 'Function')).toContain('save'); + expect(getNodesByLabel(result, 'Function')).toContain('persist'); + }); + + it('resolves u.save() to models/Models.kt and r.persist() to models/Models.kt via alias', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + const persistCall = calls.find(c => c.target === 'persist'); + + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + expect(saveCall!.targetFilePath).toBe('models/Models.kt'); + + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('main'); + expect(persistCall!.targetFilePath).toBe('models/Models.kt'); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-call resolution: User("alice") resolves to User constructor +// --------------------------------------------------------------------------- + +describe('Kotlin constructor-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-constructor-calls'), + () => {}, + ); + }, 60000); + + it('detects User class with save method and main function', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Function')).toContain('save'); + expect(getNodesByLabel(result, 'Function')).toContain('main'); + }); + + it('resolves import from app/App.kt to models/User.kt', () => { + const imports = getRelationships(result, 'IMPORTS'); + const imp = imports.find(e => e.source === 'App.kt' && e.targetFilePath === 'models/User.kt'); + expect(imp).toBeDefined(); + }); + + it('emits HAS_METHOD from User class to save function', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'User' && e.target === 'save'); + expect(edge).toBeDefined(); + expect(edge!.targetFilePath).toBe('models/User.kt'); + }); + + it('resolves user.save() as a method call to models/User.kt', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + expect(saveCall!.targetFilePath).toBe('models/User.kt'); + }); + + it('resolves calls via non-aliased import with import-resolved reason', () => { + const calls = getRelationships(result, 'CALLS'); + // Both User("alice") constructor and user.save() go through `import models.User` + for (const call of calls) { + expect(call.rel.reason).toBe('import-resolved'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Variadic resolution: vararg doesn't get filtered by arity +// --------------------------------------------------------------------------- + +describe('Kotlin variadic call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-variadic-resolution'), + () => {}, + ); + }, 60000); + + it('resolves 3-arg call to vararg function logEntry(vararg String) in Logger.kt', () => { + const calls = getRelationships(result, 'CALLS'); + const logCall = calls.find(c => c.target === 'logEntry'); + expect(logCall).toBeDefined(); + expect(logCall!.source).toBe('main'); + expect(logCall!.targetFilePath).toBe('util/Logger.kt'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('Kotlin local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves run → save to same-file definition, not the imported one', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'run'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/main/kotlin/app/Main.kt'); + }); + + it('does NOT resolve save to Logger.kt', () => { + const calls = getRelationships(result, 'CALLS'); + const saveToUtils = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/main/kotlin/utils/Logger.kt'); + expect(saveToUtils).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: val user = User() without annotation +// disambiguates user.save() vs repo.save() via TypeEnv constructor inference +// --------------------------------------------------------------------------- + +describe('Kotlin constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save functions', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + +it('resolves user.save() to models/User.kt via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/User.kt'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.save() to models/Repo.kt via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/Repo.kt'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// this.save() resolves to enclosing class's / object's own method +// --------------------------------------------------------------------------- + +describe('Kotlin this resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User, Repo classes and AppConfig object', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + expect(getNodesByLabel(result, 'Class')).toContain('AppConfig'); + }); + + it('resolves this.save() inside User.process to User.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('models/User.kt'); + }); + + it('resolves this.init() inside AppConfig.setup to AppConfig.init (object_declaration)', () => { + const calls = getRelationships(result, 'CALLS'); + const initCall = calls.find(c => c.target === 'init' && c.source === 'setup'); + expect(initCall).toBeDefined(); + expect(initCall!.targetFilePath).toBe('models/AppConfig.kt'); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: val user = getUser("alice"); user.save() +// Kotlin's CONSTRUCTOR_BINDING_SCANNER captures property_declaration with +// call_expression values, enabling return type inference from function results. +// --------------------------------------------------------------------------- + +describe('Kotlin return type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-return-type'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() to User#save via return type inference', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath?.includes('User.kt'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() to Repo#save via return type inference', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath?.includes('Repo.kt'), + ); + expect(repoSave).toBeDefined(); + }); + + it('user.save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath?.includes('Repo.kt'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS + IMPLEMENTS edges +// --------------------------------------------------------------------------- + +describe('Kotlin parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes plus Serializable interface', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['Serializable']); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits IMPLEMENTS edge: User → Serializable', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('User'); + expect(implements_[0].target).toBe('Serializable'); + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +// --------------------------------------------------------------------------- +// super.save() resolves to parent class's save method +// --------------------------------------------------------------------------- + +describe('Kotlin super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-super-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('resolves super.save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const superSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'models/BaseModel.kt'); + expect(superSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/Repo.kt'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// For-each loop variable type resolution: for (user: User in users) { user.save() } +// --------------------------------------------------------------------------- + +describe('Kotlin for-each loop type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-foreach'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save functions', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() inside for-each to models/User.kt', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.source === 'processUsers' && c.targetFilePath === 'models/User.kt'); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() inside for-each to models/Repo.kt', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.source === 'processRepos' && c.targetFilePath === 'models/Repo.kt'); + expect(repoSave).toBeDefined(); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); + + it('user.save() does NOT resolve to Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => c.target === 'save' && c.source === 'processUsers' && c.targetFilePath === 'models/Repo.kt'); + expect(wrongSave).toBeUndefined(); + }); + + it('repo.save() does NOT resolve to User.save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => c.target === 'save' && c.source === 'processRepos' && c.targetFilePath === 'models/User.kt'); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// super.save() resolves to generic parent class's save method +// --------------------------------------------------------------------------- + +describe('Kotlin generic parent super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-generic-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('resolves super.save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const superSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'models/BaseModel.kt'); + expect(superSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/Repo.kt'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable receiver unwrapping: user?.save() with User? type resolves through ?. +// --------------------------------------------------------------------------- + +describe('Kotlin nullable receiver resolution (safe calls)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Function').filter((m: string) => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user?.save() to User#save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('User.kt'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo?.save() to Repo#save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('Repo.kt'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-contaminate (exactly 1 save per receiver file)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save' && c.source === 'processEntities'); + const userTargeted = saveCalls.filter(c => c.targetFilePath.includes('User.kt')); + const repoTargeted = saveCalls.filter(c => c.targetFilePath.includes('Repo.kt')); + expect(userTargeted.length).toBe(1); + expect(repoTargeted.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// Assignment chain propagation +// --------------------------------------------------------------------------- + +describe('Kotlin assignment chain propagation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save function', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves alias.save() to User#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('User.kt'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves rAlias.save() to Repo#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('Repo.kt'), + ); + expect(repoSave).toBeDefined(); + }); + + it('alias.save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + // There should be exactly one save() call targeting User.kt from processEntities + const userSaves = calls.filter(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('User.kt'), + ); + expect(userSaves.length).toBe(1); + }); + + it('each alias resolves to its own class, not the other', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('User.kt'), + ); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('Repo.kt'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.targetFilePath).not.toBe(repoSave!.targetFilePath); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin assignment chain inside class method body. +// Tests that extractKotlinPendingAssignment handles variable_declaration +// nodes (not just property_declaration) that tree-sitter-kotlin may emit +// for function-local val/var inside class methods. +// --------------------------------------------------------------------------- + +describe('Kotlin assignment chain inside class method', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-class-method-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save function', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves alias.save() to User#save via chain inside function', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath?.includes('User.kt'), + ); + expect(userSave).toBeDefined(); + }); + + it('alias.save() in processUser does NOT resolve to Repo (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath?.includes('Repo.kt'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves alias.save() to Repo#save via chain inside function', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath?.includes('Repo.kt'), + ); + expect(repoSave).toBeDefined(); + }); + + it('alias.save() in processRepo does NOT resolve to User (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath?.includes('User.kt'), + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method calls: svc.getUser().save() +// Tests that Kotlin's navigation_expression → navigation_suffix AST structure +// is correctly handled by extractCallChain (Phase 5 review Finding 1, Round 3). +// --------------------------------------------------------------------------- + +describe('Kotlin chained method call resolution (Phase 5 review fix)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, and UserService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects getUser and save functions', () => { + const fns = getNodesByLabel(result, 'Function'); + expect(fns).toContain('getUser'); + expect(fns).toContain('save'); + }); + + it('resolves svc.getUser().save() to User#save via chain resolution', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath?.includes('User.kt'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.getUser().save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath?.includes('Repo.kt'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin unannotated for-loop Tier 1c: for (user in users) with List<User> +// --------------------------------------------------------------------------- + +describe('Kotlin unannotated for-loop type resolution (Tier 1c)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-var-foreach'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() in unannotated for to User#save via Tier 1c', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('User.kt'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in unannotated for to Repo#save via Tier 1c', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('Repo.kt'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('Repo.kt'), + ); + expect(wrong).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin when/is pattern binding: when (obj) { is User -> obj.save() } +// --------------------------------------------------------------------------- + +describe('Kotlin when/is pattern binding', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-when-pattern'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save functions', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves obj.save() in when/is User arm to models/User.kt', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processAny' && c.targetFilePath === 'models/User.kt', + ); + expect(userSave).toBeDefined(); + }); + + it('resolves obj.save() in when/is Repo arm to models/Repo.kt', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processAny' && c.targetFilePath === 'models/Repo.kt', + ); + expect(repoSave).toBeDefined(); + }); + + it('resolves obj.save() in handleUser when/is User arm to models/User.kt', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'handleUser' && c.targetFilePath === 'models/User.kt', + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT cross-resolve handleUser when/is User to Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'handleUser' && c.targetFilePath === 'models/Repo.kt', + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin HashMap .values navigation_expression resolution +// --------------------------------------------------------------------------- + +describe('Kotlin HashMap .values for-loop resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-map-keys-values'), + () => {}, + ); + }, 60000); + + it('detects User class with save function', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves user.save() via HashMap.values to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processValues' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processValues' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves user.save() via List iteration to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processList' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves user.save() via HashMap.keys to User#save (first type arg)', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processKeys' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve HashMap.keys iteration to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'save' && c.source === 'processKeys' && c.targetFilePath?.includes('Repo'), + ); + expect(wrong).toBeUndefined(); + }); + + it('resolves repo.save() via MutableMap.values to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processMutableMapValues' && c.targetFilePath?.includes('Repo'), + ); + expect(repoSave).toBeDefined(); + }); + + it('resolves repo.save() via Set iteration to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processSet' && c.targetFilePath?.includes('Repo'), + ); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin when/is complex patterns: 3+ arms, multi-call, else branch +// --------------------------------------------------------------------------- + +describe('Kotlin when/is complex pattern binding', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-when-complex'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, and Admin classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('Admin'); + }); + + // --- Three-arm when: each arm resolves obj to the correct narrowed type --- + + it('resolves obj.save() in 3-arm when/is User to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processThreeArms' && c.targetFilePath === 'models/User.kt', + ); + expect(userSave).toBeDefined(); + }); + + it('resolves obj.save() in 3-arm when/is Repo to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processThreeArms' && c.targetFilePath === 'models/Repo.kt', + ); + expect(repoSave).toBeDefined(); + }); + + it('resolves obj.save() in 3-arm when/is Admin to Admin#save', () => { + const calls = getRelationships(result, 'CALLS'); + const adminSave = calls.find(c => + c.target === 'save' && c.source === 'processThreeArms' && c.targetFilePath === 'models/Admin.kt', + ); + expect(adminSave).toBeDefined(); + }); + + // --- Multiple method calls within a single when arm --- + + it('resolves obj.validate() in when/is User arm to User#validate', () => { + const calls = getRelationships(result, 'CALLS'); + const userValidate = calls.find(c => + c.target === 'validate' && c.source === 'processMultiCall' && c.targetFilePath === 'models/User.kt', + ); + expect(userValidate).toBeDefined(); + }); + + it('resolves obj.save() in when/is User arm to User#save (multi-call)', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processMultiCall' && c.targetFilePath === 'models/User.kt', + ); + expect(userSave).toBeDefined(); + }); + + it('resolves obj.validate() in when/is Repo arm to Repo#validate', () => { + const calls = getRelationships(result, 'CALLS'); + const repoValidate = calls.find(c => + c.target === 'validate' && c.source === 'processMultiCall' && c.targetFilePath === 'models/Repo.kt', + ); + expect(repoValidate).toBeDefined(); + }); + + it('resolves obj.save() in when/is Repo arm to Repo#save (multi-call)', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processMultiCall' && c.targetFilePath === 'models/Repo.kt', + ); + expect(repoSave).toBeDefined(); + }); + + // --- Cross-resolution negatives: User arm does NOT resolve to Repo --- + + it('does NOT resolve processMultiCall when/is User arm validate() to Repo', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'validate' && c.source === 'processMultiCall' && c.targetFilePath === 'models/Repo.kt', + ); + // Both User and Repo have validate(), so the Repo arm DOES resolve here. + // But processMultiCall should NOT have a cross-arm leak. + // We test that the User arm doesn't produce a Repo edge by checking save count. + const userSaves = calls.filter(c => + c.target === 'save' && c.source === 'processMultiCall', + ); + // Exactly 2 save() CALLS edges (one per arm, not duplicated) + expect(userSaves.length).toBe(2); + }); + + // --- when with else: is User arm narrows, else does not --- + + it('resolves obj.save() in when/is User + else to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processWithElse' && c.targetFilePath === 'models/User.kt', + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve processWithElse to Repo#save or Admin#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongRepo = calls.find(c => + c.target === 'save' && c.source === 'processWithElse' && c.targetFilePath === 'models/Repo.kt', + ); + const wrongAdmin = calls.find(c => + c.target === 'save' && c.source === 'processWithElse' && c.targetFilePath === 'models/Admin.kt', + ); + expect(wrongRepo).toBeUndefined(); + expect(wrongAdmin).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin for-loop with call_expression iterable: for (user in getUsers()) +// Phase 7.3: call_expression iterable resolution via ReturnTypeLookup +// --------------------------------------------------------------------------- + +describe('Kotlin for-loop call_expression iterable resolution (Phase 7.3)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-foreach-call-expr'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() in for-loop over getUsers() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('User.kt'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in for-loop over getRepos() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('Repo.kt'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('Repo.kt'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('does NOT resolve repo.save() to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('User.kt'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution (1-level) +// --------------------------------------------------------------------------- + +describe('Field type resolution (Kotlin)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'User']); + }); + + it('detects Property nodes for Kotlin properties', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking properties to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('Address → city'); + }); + + it('resolves user.address.save() → Address#save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find( + e => e.source === 'processUser' && e.targetFilePath.includes('Models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8A: Deep field chain resolution (3-level) +// --------------------------------------------------------------------------- + +describe('Deep field chain resolution (Kotlin)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-deep-field-chain'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, City, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'City', 'User']); + }); + + it('detects Property nodes for Kotlin properties', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('city'); + expect(properties).toContain('zipCode'); + }); + + it('emits HAS_PROPERTY edges for nested type chain', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('Address → city'); + expect(edgeSet(propEdges)).toContain('City → zipCode'); + }); + + it('resolves 2-level chain: user.address.save() → Address#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'processUser'); + const addressSave = saveCalls.find(e => e.targetFilePath.includes('Models')); + expect(addressSave).toBeDefined(); + }); + + it('resolves 3-level chain: user.address.city.getName() → City#getName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'getName' && e.source === 'processUser'); + const cityGetName = getNameCalls.find(e => e.targetFilePath.includes('Models')); + expect(cityGetName).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin data class primary constructor val/var properties +// --------------------------------------------------------------------------- + +describe('Kotlin data class primary constructor property capture', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-data-class-fields'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'User']); + }); + + it('detects Property nodes for data class val parameters', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('name'); + expect(properties).toContain('address'); + expect(properties).toContain('age'); + }); + + it('emits HAS_PROPERTY edges for primary constructor properties', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → age'); + }); + + it('resolves user.address.save() → Address#save via data class field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find( + e => e.source === 'processUser' && e.targetFilePath.includes('Models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (Kotlin)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for property assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(3); + const nameWrite = writes.find(e => e.target === 'name'); + const addressWrite = writes.find(e => e.target === 'address'); + const scoreWrite = writes.find(e => e.target === 'score'); + expect(nameWrite).toBeDefined(); + expect(nameWrite!.source).toBe('updateUser'); + expect(addressWrite).toBeDefined(); + expect(addressWrite!.source).toBe('updateUser'); + expect(scoreWrite).toBeDefined(); + expect(scoreWrite!.source).toBe('updateUser'); + }); + + it('emits ACCESSES write edge for compound assignment (+=)', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + const scoreWrite = writes.find(e => e.target === 'score'); + expect(scoreWrite).toBeDefined(); + expect(scoreWrite!.source).toBe('updateUser'); + }); + + it('write ACCESSES edges have confidence 1.0', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + for (const edge of writes) { + expect(edge.rel.confidence).toBe(1.0); + } + }); +}); diff --git a/gitnexus/test/integration/resolvers/php.test.ts b/gitnexus/test/integration/resolvers/php.test.ts new file mode 100644 index 0000000000..f8ea5c5703 --- /dev/null +++ b/gitnexus/test/integration/resolvers/php.test.ts @@ -0,0 +1,1338 @@ +/** + * PHP: PSR-4 imports, extends, implements, trait use, enums, calls + ambiguous disambiguation + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: PSR-4 imports, extends, implements, trait use, enums, calls +// --------------------------------------------------------------------------- + +describe('PHP heritage & import resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-app'), + () => {}, + ); + }, 60000); + + // --- Node detection --- + + it('detects 3 classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User', 'UserService']); + }); + + it('detects 2 interfaces', () => { + expect(getNodesByLabel(result, 'Interface')).toEqual(['Loggable', 'Repository']); + }); + + it('detects 2 traits', () => { + expect(getNodesByLabel(result, 'Trait')).toEqual(['HasTimestamps', 'SoftDeletes']); + }); + + it('detects 1 enum (PHP 8.1)', () => { + expect(getNodesByLabel(result, 'Enum')).toEqual(['UserRole']); + }); + + it('detects 8 namespaces across all files', () => { + const ns = getNodesByLabel(result, 'Namespace'); + expect(ns.length).toBe(8); + }); + + // --- Heritage edges --- + + it('emits exactly 1 EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits 4 IMPLEMENTS edges: class→interface + class→trait', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(edgeSet(implements_)).toEqual([ + 'BaseModel → HasTimestamps', + 'BaseModel → Loggable', + 'User → SoftDeletes', + 'UserService → Repository', + ]); + }); + + // --- Import (use-statement) resolution via PSR-4 --- + + it('resolves 6 IMPORTS edges via PSR-4 composer.json', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(edgeSet(imports)).toEqual([ + 'BaseModel.php → HasTimestamps.php', + 'BaseModel.php → Loggable.php', + 'User.php → SoftDeletes.php', + 'UserService.php → Repository.php', + 'UserService.php → User.php', + 'UserService.php → UserRole.php', + ]); + }); + + // --- Method/function call edges --- + + it('emits CALLS edges from createUser', () => { + const calls = getRelationships(result, 'CALLS') + .filter(e => e.source === 'createUser'); + const targets = calls.map(c => c.target).sort(); + expect(targets).toContain('save'); + expect(targets).toContain('touch'); + expect(targets).toContain('label'); + }); + + it('emits CALLS edge: save → getId', () => { + const calls = getRelationships(result, 'CALLS') + .filter(e => e.source === 'save' && e.target === 'getId'); + expect(calls.length).toBe(1); + }); + + // --- Methods and properties --- + + it('detects methods on classes, interfaces, traits, and enums', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('getId'); + expect(methods).toContain('log'); + expect(methods).toContain('touch'); + expect(methods).toContain('softDelete'); + expect(methods).toContain('restore'); + expect(methods).toContain('find'); + expect(methods).toContain('save'); + expect(methods).toContain('createUser'); + expect(methods).toContain('instance'); + expect(methods).toContain('label'); + expect(methods).toContain('__construct'); + }); + + it('detects properties on classes and traits', () => { + const props = getNodesByLabel(result, 'Property'); + expect(props).toContain('id'); + expect(props).toContain('name'); + expect(props).toContain('email'); + expect(props).toContain('users'); + // $status defined in both HasTimestamps and SoftDeletes traits + expect(props.filter(p => p === 'status').length).toBe(2); + }); + + // --- Property OVERRIDES exclusion --- + + it('does not emit OVERRIDES for property name collisions ($status in both traits)', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + // OVERRIDES should only target Method nodes, never Property nodes + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); + + // --- MRO: OVERRIDES edge --- + + it('emits OVERRIDES edge for User overriding log (inherited from BaseModel)', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + expect(overrides.length).toBe(1); + const logOverride = overrides.find(e => e.source === 'User' && e.target === 'log'); + expect(logOverride).toBeDefined(); + }); + + // --- All heritage edges point to real graph nodes --- + + it('all heritage edges point to real graph nodes (no synthetic)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + const implements_ = getRelationships(result, 'IMPLEMENTS'); + + for (const edge of [...extends_, ...implements_]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: Handler + Dispatchable, PSR-4 use-imports disambiguate +// --------------------------------------------------------------------------- + +describe('PHP ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler classes and 2 Dispatchable interfaces', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes.filter(n => n === 'Handler').length).toBe(2); + const ifaces = getNodesByLabel(result, 'Interface'); + expect(ifaces.filter(n => n === 'Dispatchable').length).toBe(2); + }); + + it('resolves EXTENDS to app/Models/Handler.php (not app/Other/)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('UserHandler'); + expect(extends_[0].target).toBe('Handler'); + expect(extends_[0].targetFilePath).toBe('app/Models/Handler.php'); + }); + + it('resolves IMPLEMENTS to app/Models/Dispatchable.php (not app/Other/)', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('UserHandler'); + expect(implements_[0].target).toBe('Dispatchable'); + expect(implements_[0].targetFilePath).toBe('app/Models/Dispatchable.php'); + }); + + it('import edges point to app/Models/ not app/Other/', () => { + const imports = getRelationships(result, 'IMPORTS'); + for (const imp of imports) { + expect(imp.targetFilePath).toMatch(/^app\/Models\//); + } + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +describe('PHP call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-calls'), + () => {}, + ); + }, 60000); + + it('resolves create_user → write_audit to app/Utils/OneArg/log.php via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('create_user'); + expect(calls[0].target).toBe('write_audit'); + expect(calls[0].targetFilePath).toBe('app/Utils/OneArg/log.php'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: $obj->method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('PHP member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves processUser → save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + expect(saveCall!.targetFilePath).toBe('app/Models/User.php'); + }); + + it('detects User class and save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('emits HAS_METHOD edge from User to save', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'User' && e.target === 'save'); + expect(edge).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor resolution: new User() resolves to Class node +// --------------------------------------------------------------------------- + +describe('PHP constructor-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-constructor-calls'), + () => {}, + ); + }, 60000); + + it('resolves new User() as a CALLS edge to the User class', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.source).toBe('processUser'); + expect(ctorCall!.targetLabel).toBe('Class'); + expect(ctorCall!.targetFilePath).toBe('Models/User.php'); + expect(ctorCall!.rel.reason).toBe('import-resolved'); + }); + + it('also resolves $user->save() as a member call', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + }); + + it('detects User class, __construct method, and save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('__construct'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed parameters disambiguate same-named methods +// --------------------------------------------------------------------------- + +describe('PHP receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves $user->save() to User.save and $repo->save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'app/Models/User.php'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'app/Models/Repo.php'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + expect(repoSave!.source).toBe('processEntities'); + }); +}); + +// --------------------------------------------------------------------------- +// Alias import resolution: use App\Models\User as U resolves U → User +// --------------------------------------------------------------------------- + +describe('PHP alias import resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-alias-imports'), + () => {}, + ); + }, 60000); + + it('detects Main, Repo, and User classes with save and persist methods', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Main', 'Repo', 'User']); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + expect(getNodesByLabel(result, 'Method')).toContain('persist'); + }); + + it('resolves $u->save() to User.php and $r->persist() to Repo.php via alias', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + const persistCall = calls.find(c => c.target === 'persist'); + + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('run'); + expect(saveCall!.targetLabel).toBe('Method'); + expect(saveCall!.targetFilePath).toBe('app/Models/User.php'); + + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('run'); + expect(persistCall!.targetLabel).toBe('Method'); + expect(persistCall!.targetFilePath).toBe('app/Models/Repo.php'); + }); + + it('emits exactly 2 IMPORTS edges via alias resolution', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(2); + expect(edgeSet(imports)).toEqual([ + 'Main.php → Repo.php', + 'Main.php → User.php', + ]); + }); +}); + +// --------------------------------------------------------------------------- +// Grouped import with alias: use App\Models\{User, Repo as R} +// --------------------------------------------------------------------------- + +describe('PHP grouped import with alias', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-grouped-imports'), + () => {}, + ); + }, 60000); + + it('detects Main, Repo, and User classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Main', 'Repo', 'User']); + }); + + it('resolves $r->persist() to Repo.php via grouped alias', () => { + const calls = getRelationships(result, 'CALLS'); + const persistCall = calls.find(c => c.target === 'persist'); + + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('run'); + expect(persistCall!.targetFilePath).toBe('app/Models/Repo.php'); + }); + + it('resolves $u->save() to User.php via grouped import', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('run'); + expect(saveCall!.targetFilePath).toBe('app/Models/User.php'); + }); + + it('resolves non-aliased User via NamedImportMap (not just the aliased Repo)', () => { + // Both User (non-aliased) and R→Repo (aliased) should resolve through grouped import + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'run'); + const persistCall = calls.find(c => c.target === 'persist' && c.source === 'run'); + expect(saveCall).toBeDefined(); + expect(persistCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('app/Models/User.php'); + expect(persistCall!.targetFilePath).toBe('app/Models/Repo.php'); + }); +}); + +// --------------------------------------------------------------------------- +// Variadic resolution: ...$args don't get filtered by arity +// --------------------------------------------------------------------------- + +describe('PHP variadic call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-variadic-resolution'), + () => {}, + ); + }, 60000); + + it('resolves run → Logger.record despite extra args (variadic)', () => { + const calls = getRelationships(result, 'CALLS'); + const recordCall = calls.find(c => c.target === 'record'); + expect(recordCall).toBeDefined(); + expect(recordCall!.source).toBe('run'); + expect(recordCall!.targetFilePath).toBe('app/Utils/Logger.php'); + }); + + it('detects Logger class and record method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('Logger'); + expect(getNodesByLabel(result, 'Method')).toContain('record'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('PHP local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves run → save to same-file definition, not the imported one', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'run'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('app/Services/Main.php'); + }); + + it('does NOT resolve save to Logger.php', () => { + const calls = getRelationships(result, 'CALLS'); + const saveToUtils = calls.find(c => c.target === 'save' && c.targetFilePath === 'app/Utils/Logger.php'); + expect(saveToUtils).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: $user = new User(); $user->save() +// PHP object_creation_expression (no typed local variable annotations) +// --------------------------------------------------------------------------- + +describe('PHP constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves $user->save() to app/Models/User.php via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'app/Models/User.php'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves $repo->save() to app/Models/Repo.php via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'app/Models/Repo.php'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// $this->save() resolves to enclosing class's own save method +// --------------------------------------------------------------------------- + +describe('PHP $this resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves $this->save() inside User.process to User.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('app/Models/User.php'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS + IMPLEMENTS edges +// --------------------------------------------------------------------------- + +describe('PHP parent class resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes plus Serializable interface', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['Serializable']); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits IMPLEMENTS edge: User → Serializable', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('User'); + expect(implements_[0].target).toBe('Serializable'); + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +// --------------------------------------------------------------------------- +// parent::save() resolves to parent class's save method +// --------------------------------------------------------------------------- + +describe('PHP parent:: resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-super-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('resolves parent::save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const parentSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'app/Models/BaseModel.php'); + expect(parentSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'app/Models/Repo.php'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// PHP 8.0+ constructor property promotion: __construct(private UserRepo $repo) +// --------------------------------------------------------------------------- + +describe('PHP constructor property promotion resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-property-promotion'), + () => {}, + ); + }, 60000); + + it('detects UserRepo and UserService classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserRepo'); + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + }); + + it('resolves $repo->save() inside constructor via promoted parameter type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === '__construct'); + expect(saveCall).toBeDefined(); + }); + + // NOTE: $this->repo->save() in other methods requires multi-step receiver resolution + // (chained property access), which is a cross-language architectural feature not yet + // implemented. The promoted parameter type IS extracted into the TypeEnv — it just + // can't be accessed via $this->property chains yet. +}); + +// --------------------------------------------------------------------------- +// PHP 7.4+ typed class property resolution: private UserRepo $repo; +// --------------------------------------------------------------------------- + +describe('PHP typed class property resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-typed-properties'), + () => {}, + ); + }, 60000); + + it('detects UserRepo and UserService classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserRepo'); + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + }); + + it('detects typed property $repo on UserService', () => { + expect(getNodesByLabel(result, 'Property')).toContain('repo'); + }); + + it('detects find and save methods on UserRepo', () => { + expect(getNodesByLabel(result, 'Method')).toContain('find'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('resolves $repo->save() to UserRepo.php via parameter type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('app/Models/UserRepo.php'); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: $user = $this->getUser("alice"); $user->save() +// PHP's scanConstructorBinding captures assignment_expression with both +// function_call_expression and member_call_expression values, enabling +// return type inference for method calls on objects. +// --------------------------------------------------------------------------- + +describe('PHP return type inference via member call', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-return-type'), + () => {}, + ); + }, 60000); + + it('detects User, UserService, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('detects save on both User and Repo, and getUser method', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('save'); + expect(methods).toContain('getUser'); + // save exists on both User and Repo — disambiguation required + expect(methods.filter((m: string) => m === 'save').length).toBe(2); + }); + + it('resolves $user->save() to User#save (not Repo#save) via return type of getUser(): User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('User.php'), + ); + expect(saveCall).toBeDefined(); + // Must NOT resolve to Repo.save — that would mean disambiguation failed + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('Repo.php'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// PHPDoc @return annotation: return type inference without native type hints +// --------------------------------------------------------------------------- + +describe('PHP return type inference via PHPDoc @return annotation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-phpdoc-return-type'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves $user->save() to User#save via PHPDoc @return User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves $repo->save() to Repo#save via PHPDoc @return Repo', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves $user->save() via PHPDoc @param User $user in handleUser()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'handleUser' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves $repo->save() via PHPDoc @param Repo $repo in handleRepo()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'handleRepo' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// PHPDoc @return with PHP 8+ attributes (#[Route]) between doc-comment and method +// --------------------------------------------------------------------------- + +describe('PHP PHPDoc @return with attributes between comment and method', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-phpdoc-attribute-return-type'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves $user->save() to User#save despite #[Route] attribute between PHPDoc and method', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves $repo->save() to Repo#save despite #[Route] attribute between PHPDoc and method', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves $user->save() via PHPDoc @param despite #[Validate] attribute', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'handleUser' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves $repo->save() via PHPDoc @param despite #[Validate] attribute', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'handleRepo' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// $this->method() receiver disambiguation: two classes with same method name +// --------------------------------------------------------------------------- + +describe('PHP $this->method() receiver disambiguation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-this-receiver-disambiguation'), + () => {}, + ); + }, 60000); + + it('detects UserService and AdminService classes, both with getUser methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + expect(getNodesByLabel(result, 'Class')).toContain('AdminService'); + const getUserMethods = getNodesByLabel(result, 'Method').filter(m => m === 'getUser'); + expect(getUserMethods.length).toBe(2); + }); + + it('resolves $user->save() in UserService to User#save via $this->getUser() disambiguation', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves $repo->save() in AdminService to Repo#save via $this->getUser() disambiguation', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processAdmin' && c.targetFilePath.includes('Models.php'), + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable receiver unwrapping: ?User type hint stripped to User for resolution +// --------------------------------------------------------------------------- + +describe('PHP nullable receiver resolution (?Type hint)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter((m: string) => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves $user->save() to User#save via nullable param type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('User.php'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves $repo->save() to Repo#save via nullable param type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('Repo.php'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-contaminate (exactly 1 save per receiver file)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save' && c.source === 'process'); + const userTargeted = saveCalls.filter(c => c.targetFilePath.includes('User.php')); + const repoTargeted = saveCalls.filter(c => c.targetFilePath.includes('Repo.php')); + expect(userTargeted.length).toBe(1); + expect(repoTargeted.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// Assignment chain propagation +// --------------------------------------------------------------------------- + +describe('PHP assignment chain propagation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves alias->save() to User#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('User.php'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves rAlias->save() to Repo#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('Repo.php'), + ); + expect(repoSave).toBeDefined(); + }); + + it('alias->save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + // There should be exactly one save() call targeting User.php from process + const userSaves = calls.filter(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('User.php'), + ); + expect(userSaves.length).toBe(1); + }); + + it('each alias resolves to its own class, not the other', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('User.php'), + ); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('Repo.php'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.targetFilePath).not.toBe(repoSave!.targetFilePath); + }); +}); + +// --------------------------------------------------------------------------- +// PHP foreach ($users as $user) — Tier 1c +// --------------------------------------------------------------------------- + +describe('PHP foreach loop resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-foreach-loop'), + () => {}, + ); + }, 60000); + + it('detects User class with save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves $user->save() in foreach to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve $user->save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// PHP foreach with PHPDoc generic Collection<User> — element type extraction +// Bug fix: normalizePhpType('Collection<User>') must yield 'User', not 'Collection' +// --------------------------------------------------------------------------- + +describe('PHP foreach with PHPDoc generic Collection<User>', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-foreach-generic'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves $user->save() in foreach with Collection<User> PHPDoc to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processCollection' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve Collection<User> foreach to Repo#save (false binding regression)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processCollection' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('User[] array-style PHPDoc still resolves correctly (regression check)', () => { + const calls = getRelationships(result, 'CALLS'); + const arraySave = calls.find(c => + c.target === 'save' && c.source === 'processArray', + ); + expect(arraySave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// PHP foreach ($this->users as $user) — member access key mismatch fix +// Bug fix: member_access_expression.name returns 'users' but scopeEnv stores '$users' +// --------------------------------------------------------------------------- + +describe('PHP foreach with $this->property member access', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-foreach-member-access'), + () => {}, + ); + }, 60000); + + it('detects User class with save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('resolves $user->save() in foreach($this->users) to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processMembers' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve $this->users foreach to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processMembers' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// PHP foreach with call_expression iterable: foreach (getUsers() as $user) +// Phase 7.3: function_call_expression iterable resolution via ReturnTypeLookup +// --------------------------------------------------------------------------- + +describe('PHP foreach call_expression iterable resolution (Phase 7.3)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-foreach-call-expr'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves $user->save() in foreach over getUsers() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves $repo->save() in foreach over getRepos() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('Repo'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT resolve $user->save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('Repo'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('does NOT resolve $repo->save() to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('User'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution (1-level) +// --------------------------------------------------------------------------- + +describe('Field type resolution (PHP)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, Service, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'Service', 'User']); + }); + + it('detects Property nodes for PHP properties', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking properties to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + }); + + it('resolves $user->address->save() → Address#save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find( + e => e.source === 'processUser' && e.targetFilePath.includes('Models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8A: Deep field chain resolution (3-level) +// --------------------------------------------------------------------------- + +describe('Deep field chain resolution (PHP)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-deep-field-chain'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, City, Service, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'City', 'Service', 'User']); + }); + + it('detects Property nodes for PHP properties', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('city'); + expect(properties).toContain('zipCode'); + }); + + it('emits HAS_PROPERTY edges for nested type chain', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(5); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('Address → city'); + expect(edgeSet(propEdges)).toContain('Address → street'); + expect(edgeSet(propEdges)).toContain('City → zipCode'); + }); + + it('resolves 2-level chain: $user->address->save() → Address#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'processUser'); + const addressSave = saveCalls.find(e => e.targetFilePath.includes('Models')); + expect(addressSave).toBeDefined(); + }); + + it('resolves 3-level chain: $user->address->city->getName() → City#getName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'getName' && e.source === 'processUser'); + const cityGetName = getNameCalls.find(e => e.targetFilePath.includes('Models')); + expect(cityGetName).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// PHP 8.0+ constructor promotion as property declarations +// --------------------------------------------------------------------------- + +describe('PHP constructor promotion property capture', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-constructor-promotion-fields'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, Service, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'Service', 'User']); + }); + + it('detects Property nodes for promoted constructor parameters', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('name'); + expect(properties).toContain('address'); + }); + + it('emits HAS_PROPERTY edges for promoted parameters', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('User → address'); + }); + + it('resolves $user->address->save() → Address#save via promoted field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find( + e => e.source === 'processUser' && e.targetFilePath.includes('Models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (PHP)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'php-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for field assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(3); + const nameWrite = writes.find(e => e.target === 'name'); + const addressWrite = writes.find(e => e.target === 'address'); + const countWrite = writes.find(e => e.target === 'count'); + expect(nameWrite).toBeDefined(); + expect(nameWrite!.source).toBe('updateUser'); + expect(addressWrite).toBeDefined(); + expect(addressWrite!.source).toBe('updateUser'); + expect(countWrite).toBeDefined(); + expect(countWrite!.source).toBe('updateUser'); + }); + + it('emits ACCESSES write edge for static property assignment', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + const countWrite = writes.find(e => e.target === 'count'); + expect(countWrite).toBeDefined(); + expect(countWrite!.source).toBe('updateUser'); + }); + + it('write ACCESSES edges have confidence 1.0', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + for (const edge of writes) { + expect(edge.rel.confidence).toBe(1.0); + } + }); +}); diff --git a/gitnexus/test/integration/resolvers/python.test.ts b/gitnexus/test/integration/resolvers/python.test.ts new file mode 100644 index 0000000000..bdbf58c554 --- /dev/null +++ b/gitnexus/test/integration/resolvers/python.test.ts @@ -0,0 +1,1384 @@ +/** + * Python: relative imports + class inheritance + ambiguous module disambiguation + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: relative imports + class inheritance +// --------------------------------------------------------------------------- + +describe('Python relative import & heritage resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-pkg'), + () => {}, + ); + }, 60000); + + it('detects exactly 3 classes and 5 functions', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['AuthService', 'BaseModel', 'User']); + expect(getNodesByLabel(result, 'Function')).toEqual(['authenticate', 'get_name', 'process_model', 'save', 'validate']); + }); + + it('emits exactly 1 EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('resolves all 3 relative imports', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(3); + expect(edgeSet(imports)).toEqual([ + 'auth.py → user.py', + 'helpers.py → base.py', + 'user.py → base.py', + ]); + }); + + it('emits exactly 3 CALLS edges', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(3); + expect(edgeSet(calls)).toEqual([ + 'authenticate → validate', + 'process_model → save', + 'process_model → validate', + ]); + }); + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: Handler in two packages, relative import disambiguates +// --------------------------------------------------------------------------- + +describe('Python ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes.filter(n => n === 'Handler').length).toBe(2); + expect(classes).toContain('UserHandler'); + }); + + it('resolves EXTENDS to models/handler.py (not other/handler.py)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('UserHandler'); + expect(extends_[0].target).toBe('Handler'); + expect(extends_[0].targetFilePath).toBe('models/handler.py'); + }); + + it('import edge points to models/ not other/', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(1); + expect(imports[0].targetFilePath).toBe('models/handler.py'); + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of getRelationships(result, 'EXTENDS')) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + } + }); +}); + +describe('Python call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-calls'), + () => {}, + ); + }, 60000); + + it('resolves run → write_audit to one.py via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('run'); + expect(calls[0].target).toBe('write_audit'); + expect(calls[0].targetFilePath).toBe('one.py'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('Python member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves process_user → save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('process_user'); + expect(saveCall!.targetFilePath).toBe('user.py'); + }); + + it('detects User class and save function (Python methods are Function nodes)', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + // Python tree-sitter captures all function_definitions as Function, including methods + expect(getNodesByLabel(result, 'Function')).toContain('save'); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed variables disambiguate same-named methods +// --------------------------------------------------------------------------- + +describe('Python receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save functions', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + // Python tree-sitter captures all function_definitions as Function + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() to User.save and repo.save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'user.py'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'repo.py'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('process_entities'); + expect(repoSave!.source).toBe('process_entities'); + }); +}); + +// --------------------------------------------------------------------------- +// Named import disambiguation: two modules export same name, from-import resolves +// --------------------------------------------------------------------------- + +describe('Python named import disambiguation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-named-imports'), + () => {}, + ); + }, 60000); + + it('resolves process_input → format_data to format_upper.py via from-import', () => { + const calls = getRelationships(result, 'CALLS'); + const formatCall = calls.find(c => c.target === 'format_data'); + expect(formatCall).toBeDefined(); + expect(formatCall!.source).toBe('process_input'); + expect(formatCall!.targetFilePath).toBe('format_upper.py'); + }); + + it('emits IMPORTS edge to format_upper.py', () => { + const imports = getRelationships(result, 'IMPORTS'); + const appImport = imports.find(e => e.source === 'app.py'); + expect(appImport).toBeDefined(); + expect(appImport!.targetFilePath).toBe('format_upper.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Variadic resolution: *args don't get filtered by arity +// --------------------------------------------------------------------------- + +describe('Python variadic call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-variadic-resolution'), + () => {}, + ); + }, 60000); + + it('resolves process_input → log_entry to logger.py despite 3 args vs *args', () => { + const calls = getRelationships(result, 'CALLS'); + const logCall = calls.find(c => c.target === 'log_entry'); + expect(logCall).toBeDefined(); + expect(logCall!.source).toBe('process_input'); + expect(logCall!.targetFilePath).toBe('logger.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Alias import resolution: from x import User as U resolves U → User +// --------------------------------------------------------------------------- + +describe('Python alias import resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-alias-imports'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + }); + + it('resolves u.save() to models.py and r.persist() to models.py via alias', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + const persistCall = calls.find(c => c.target === 'persist'); + + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + expect(saveCall!.targetFilePath).toBe('models.py'); + + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('main'); + expect(persistCall!.targetFilePath).toBe('models.py'); + }); + + it('emits exactly 1 IMPORTS edge: app.py → models.py', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(1); + expect(imports[0].sourceFilePath).toBe('app.py'); + expect(imports[0].targetFilePath).toBe('models.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Re-export chain: from .base import X barrel pattern via __init__.py +// --------------------------------------------------------------------------- + +describe('Python re-export chain resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-reexport-chain'), + () => {}, + ); + }, 60000); + + it('resolves user.save() through __init__.py barrel to models/base.py', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + expect(saveCall!.targetFilePath).toBe('models/base.py'); + }); + + it('resolves repo.persist() through __init__.py barrel to models/base.py', () => { + const calls = getRelationships(result, 'CALLS'); + const persistCall = calls.find(c => c.target === 'persist'); + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('main'); + expect(persistCall!.targetFilePath).toBe('models/base.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('Python local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves save("test") to local save in app.py, not utils.py', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'main'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('app.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Bare import: `import user` from services/auth.py resolves to services/user.py +// not models/user.py, even though models/ is indexed first (proximity wins) +// --------------------------------------------------------------------------- + +describe('Python bare import resolution (proximity over index order)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-bare-import'), + () => {}, + ); + }, 60000); + + it('detects User in models/ and UserService in services/', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + }); + + it('resolves `import user` from services/auth.py to services/user.py, not models/user.py', () => { + const imports = getRelationships(result, 'IMPORTS'); + const imp = imports.find(e => e.sourceFilePath === 'services/auth.py'); + expect(imp).toBeDefined(); + expect(imp!.targetFilePath).toBe('services/user.py'); + expect(imp!.targetFilePath).not.toBe('models/user.py'); + }); + + it('resolves svc.execute() CALLS edge to UserService#execute in services/user.py', () => { + // End-to-end: correct IMPORTS resolution must propagate through type inference + // so that user.UserService() binds svc → UserService, and svc.execute() resolves + const calls = getRelationships(result, 'CALLS'); + const executeCall = calls.find(c => c.target === 'execute' && c.targetFilePath === 'services/user.py'); + expect(executeCall).toBeDefined(); + expect(executeCall!.source).toBe('authenticate'); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: user = User(); user.save() → User.save +// Cross-file SymbolTable verification (no explicit type annotations) +// --------------------------------------------------------------------------- + +describe('Python constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() to models/user.py via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/user.py'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('process_entities'); + }); + + it('resolves repo.save() to models/repo.py via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/repo.py'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('process_entities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-call resolution: User("alice") resolves to User class +// --------------------------------------------------------------------------- + +describe('Python constructor-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-constructor-calls'), + () => {}, + ); + }, 60000); + + it('detects User class with __init__ and save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Function')).toContain('__init__'); + expect(getNodesByLabel(result, 'Function')).toContain('save'); + expect(getNodesByLabel(result, 'Function')).toContain('process'); + }); + + it('resolves import from app.py to models.py', () => { + const imports = getRelationships(result, 'IMPORTS'); + const imp = imports.find(e => e.source === 'app.py' && e.targetFilePath === 'models.py'); + expect(imp).toBeDefined(); + }); + + it('emits HAS_METHOD from User class to __init__ and save', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const initEdge = hasMethod.find(e => e.source === 'User' && e.target === '__init__'); + const saveEdge = hasMethod.find(e => e.source === 'User' && e.target === 'save'); + expect(initEdge).toBeDefined(); + expect(saveEdge).toBeDefined(); + }); + + it('resolves user.save() as a method call to models.py', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('process'); + expect(saveCall!.targetFilePath).toBe('models.py'); + }); +}); + +// --------------------------------------------------------------------------- +// self.save() resolves to enclosing class's own save method +// --------------------------------------------------------------------------- + +describe('Python self resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a save function', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves self.save() inside User.process to User.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('models/user.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS edge +// --------------------------------------------------------------------------- + +describe('Python parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('EXTENDS edge points to real graph node in base.py', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + const target = result.graph.getNode(extends_[0].rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.filePath).toBe('models/base.py'); + }); +}); + +// --------------------------------------------------------------------------- +// super().save() resolves to parent class's save method +// --------------------------------------------------------------------------- + +describe('Python super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-super-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('resolves super().save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const superSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'models/base.py'); + expect(superSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/repo.py'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Python qualified constructor: user = models.User("alice"); user.save() +// --------------------------------------------------------------------------- + +describe('Python qualified constructor inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-qualified-constructor'), + () => {}, + ); + }, 60000); + + it('resolves user.save() via qualified constructor (models.User)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.targetFilePath === 'models.py'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + }); + + it('resolves user.greet() via qualified constructor (models.User)', () => { + const calls = getRelationships(result, 'CALLS'); + const greetCall = calls.find(c => c.target === 'greet' && c.targetFilePath === 'models.py'); + expect(greetCall).toBeDefined(); + expect(greetCall!.source).toBe('main'); + }); +}); + +// --------------------------------------------------------------------------- +// Walrus operator: if (user := User("alice")): user.save() +// --------------------------------------------------------------------------- + +describe('Python walrus operator type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-walrus-operator'), + () => {}, + ); + }, 60000); + + it('detects User class with save and greet methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Function')).toContain('save'); + expect(getNodesByLabel(result, 'Function')).toContain('greet'); + }); + + it('resolves user.save() via walrus operator constructor inference', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.targetFilePath === 'models.py'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('process'); + }); +}); + +// --------------------------------------------------------------------------- +// Class-level annotations: file-scope `user: User` disambiguates method calls +// --------------------------------------------------------------------------- + +describe('Python class-level annotation resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-class-annotations'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves active_user.save() to User.save via file-level annotation', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'user.py'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('process'); + }); + + it('resolves active_repo.save() to Repo.save via file-level annotation', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'repo.py'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('process'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: user = get_user('alice'); user.save() +// Python's scanner captures ALL call assignments, enabling return type inference. +// --------------------------------------------------------------------------- + +describe('Python return type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-return-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User class', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('detects get_user and save symbols', () => { + // Python methods inside classes may be labeled Method or Function depending on nesting + const allSymbols = [...getNodesByLabel(result, 'Function'), ...getNodesByLabel(result, 'Method')]; + expect(allSymbols).toContain('get_user'); + expect(allSymbols).toContain('save'); + }); + + it('resolves user.save() to User#save via return type inference from get_user() -> User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_user' + ); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toContain('models.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Issue #289: static/classmethod classes must have HAS_METHOD edges +// --------------------------------------------------------------------------- + +describe('Python static/classmethod class resolution (issue #289)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-static-class-methods'), + () => {}, + ); + }, 60000); + + it('detects UserService and AdminService classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + expect(getNodesByLabel(result, 'Class')).toContain('AdminService'); + }); + + it('detects all static/class methods as symbols', () => { + const allSymbols = [...getNodesByLabel(result, 'Function'), ...getNodesByLabel(result, 'Method')]; + expect(allSymbols).toContain('find_user'); + expect(allSymbols).toContain('create_user'); + expect(allSymbols).toContain('from_config'); + expect(allSymbols).toContain('delete_user'); + }); + + it('emits HAS_METHOD edges linking static methods to their enclosing class', () => { + // This is the core of issue #289: without HAS_METHOD, context() and impact() + // return empty for classes whose methods are all @staticmethod/@classmethod + const hasMethod = getRelationships(result, 'HAS_METHOD'); + + const userServiceMethods = hasMethod.filter(e => e.source === 'UserService'); + expect(userServiceMethods.length).toBe(3); // find_user, create_user, from_config + + const adminServiceMethods = hasMethod.filter(e => e.source === 'AdminService'); + expect(adminServiceMethods.length).toBe(2); // find_user, delete_user + }); + + it('resolves unique static method calls (create_user, delete_user, from_config)', () => { + const calls = getRelationships(result, 'CALLS'); + // delete_user is unique to AdminService — should resolve + const deleteCall = calls.find(c => + c.target === 'delete_user' && c.source === 'process' && c.targetFilePath.includes('service.py'), + ); + expect(deleteCall).toBeDefined(); + + // create_user is unique to UserService — should resolve + const createCall = calls.find(c => + c.target === 'create_user' && c.source === 'process' && c.targetFilePath.includes('service.py'), + ); + expect(createCall).toBeDefined(); + }); + + it('resolves find_user() via class-as-receiver for static method calls', () => { + // UserService.find_user() and AdminService.find_user() are both resolved because + // the class name (UserService / AdminService) is used as the receiver type for + // disambiguation. Both find_user methods share the same nodeId (same file, same name) + // so exactly 1 CALLS edge is emitted — which is correct (not ambiguous, not missing). + const calls = getRelationships(result, 'CALLS'); + const findCalls = calls.filter(c => + c.target === 'find_user' && c.source === 'process', + ); + expect(findCalls.length).toBe(1); + expect(findCalls[0].targetFilePath).toContain('service.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable receiver: user: User | None = find_user(); user.save() +// Python 3.10+ union syntax — stripNullable unwraps `User | None` → `User` +// --------------------------------------------------------------------------- + +describe('Python nullable receiver resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save functions', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() to User.save via nullable receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'user.py'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('process_entities'); + }); + + it('resolves repo.save() to Repo.save via nullable receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'repo.py'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('process_entities'); + }); + + it('user.save() does NOT resolve to Repo.save (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save' && c.source === 'process_entities'); + // Each save() call should resolve to exactly one target file + const userSaveToRepo = saveCalls.filter(c => c.targetFilePath === 'repo.py'); + const repoSaveToUser = saveCalls.filter(c => c.targetFilePath === 'user.py'); + // Exactly 1 edge to each file (not 2 to either) + expect(userSaveToRepo.length).toBe(1); + expect(repoSaveToUser.length).toBe(1); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Assignment chain propagation (Phase 4.3) +// --------------------------------------------------------------------------- + +describe('Python assignment chain propagation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves alias.save() to User#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + // Positive: alias.save() must resolve to User#save + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('alias.save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + // Negative: only one save call from process to User#save + const wrongCall = calls.filter(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('user.py'), + ); + expect(wrongCall.length).toBe(1); + }); + + it('resolves r_alias.save() to Repo#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + // Positive: r_alias.save() must resolve to Repo#save + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('repo.py'), + ); + expect(repoSave).toBeDefined(); + }); + + it('each alias resolves to its own class, not the other', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('user.py'), + ); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath.includes('repo.py'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.targetFilePath).not.toBe(repoSave!.targetFilePath); + }); +}); + +// --------------------------------------------------------------------------- +// Python nullable (User | None) + assignment chain combined. +// Python 3.10+ union syntax is parsed as binary_operator by tree-sitter, +// stored as raw text "User | None" in TypeEnv. stripNullable's +// NULLABLE_KEYWORDS.has() path must resolve it at lookup time. +// --------------------------------------------------------------------------- + +describe('Python nullable (User | None) + assignment chain combined', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-nullable-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves alias.save() to User#save when source is User | None', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'nullable_chain_user' && c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('alias.save() from User | None does NOT resolve to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'nullable_chain_user' && c.targetFilePath?.includes('repo.py'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves alias.save() to Repo#save when source is Repo | None', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'nullable_chain_repo' && c.targetFilePath?.includes('repo.py'), + ); + expect(repoSave).toBeDefined(); + }); + + it('alias.save() from Repo | None does NOT resolve to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'nullable_chain_repo' && c.targetFilePath?.includes('user.py'), + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Python walrus operator (:=) assignment chain. +// Tests that extractPendingAssignment handles named_expression nodes +// in addition to regular assignment nodes. +// --------------------------------------------------------------------------- + +describe('Python walrus operator (:=) assignment chain', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-walrus-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save function', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves alias.save() to User#save via regular + walrus chains', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'walrus_chain_user' && c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('save() in walrus_chain_user does NOT resolve to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'walrus_chain_user' && c.targetFilePath?.includes('repo.py'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves alias.save() to Repo#save via regular + walrus chains', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'walrus_chain_repo' && c.targetFilePath?.includes('repo.py'), + ); + expect(repoSave).toBeDefined(); + }); + + it('save() in walrus_chain_repo does NOT resolve to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'walrus_chain_repo' && c.targetFilePath?.includes('user.py'), + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Python match/case as-pattern binding: `case User() as u: u.save()` +// Tests Phase 6 extractPatternBinding for Python's match statement. +// --------------------------------------------------------------------------- + +describe('Python match/case as-pattern type binding', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-match-case'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('DEBUG: shows pipeline result details', () => { + const calls = getRelationships(result, 'CALLS'); + console.log('ALL CALLS:', JSON.stringify(calls.map(c => ({ source: c.source, target: c.target, targetFilePath: c.targetFilePath })))); + // Check all relationships + const allRels: string[] = []; + result.graph.iterRelationships && [...result.graph.iterRelationships()].forEach(r => { + const src = result.graph.getNode(r.sourceId); + const tgt = result.graph.getNode(r.targetId); + allRels.push(r.type + ': ' + src?.properties.name + ' -> ' + tgt?.properties.name); + }); + console.log('ALL RELATIONSHIPS:', allRels.join(', ')); + expect(true).toBe(true); + }); + + // Skip: call extraction issue, NOT a type-env limitation. + // Type-env binding works correctly (unit test passes). The root cause is likely + // in call-processor's findEnclosingFunction scope resolution within match_statement + // blocks, not the tree-sitter query patterns (which descend recursively by default). + it.skip('resolves u.save() to User#save via match/case as-pattern binding', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it.skip('does NOT resolve u.save() to Repo#save (negative disambiguation)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath?.includes('repo.py'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method calls: svc.get_user().save() +// Tests that Python's scanner correctly handles method-call chains where +// the intermediate receiver type is inferred from the return type annotation. +// --------------------------------------------------------------------------- + +describe('Python chained method call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, and UserService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects get_user and save functions', () => { + const allSymbols = [...getNodesByLabel(result, 'Function'), ...getNodesByLabel(result, 'Method')]; + expect(allSymbols).toContain('get_user'); + expect(allSymbols).toContain('save'); + }); + + it('resolves svc.get_user().save() to User#save via chain resolution', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'process_user' && + c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.get_user().save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'process_user' && + c.targetFilePath?.includes('repo.py'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// for key, user in data.items() — dict.items() call iterable + tuple unpacking +// --------------------------------------------------------------------------- + +describe('Python dict.items() for-loop resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-dict-items-loop'), + () => {}, + ); + }, 60000); + + it('detects User class with save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves user.save() via dict.items() loop to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath?.includes('repo.py'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// self.users member access iterable: for user in self.users +// --------------------------------------------------------------------------- + +describe('Python member access iterable for-loop', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-member-access-for-loop'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + // Python tree-sitter captures all function_definitions as Function, including methods + expect(getNodesByLabel(result, 'Function')).toContain('save'); + }); + + it('resolves user.save() via self.users to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('repo.py'), + ); + expect(wrong).toBeUndefined(); + }); + + it('resolves repo.save() via self.repos to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process_repos' && c.targetFilePath?.includes('repo.py'), + ); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Python for-loop with call_expression iterable: for user in get_users() +// Phase 7.3: call_expression iterable resolution via ReturnTypeLookup +// --------------------------------------------------------------------------- + +describe('Python for-loop call_expression iterable resolution (Phase 7.3)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-for-call-expr'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() in for-loop over get_users() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('models.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in for-loop over get_repos() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process_repos' && c.targetFilePath?.includes('models.py'), + ); + expect(repoSave).toBeDefined(); + }); + + it('process_users resolves exactly one save call (no cross-binding)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => + c.target === 'save' && c.source === 'process_users', + ); + expect(saveCalls.length).toBe(1); + }); + + it('process_repos resolves exactly one save call (no cross-binding)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => + c.target === 'save' && c.source === 'process_repos', + ); + expect(saveCalls.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// enumerate() for-loop: for i, k, v in enumerate(d.items()) +// --------------------------------------------------------------------------- + +describe('Python enumerate() for-loop resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-enumerate-loop'), + () => {}, + ); + }, 60000); + + it('detects User class with save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves v.save() in enumerate(users.items()) loop to User#save', () => { + // for i, k, v in enumerate(users.items()): v.save() + // v must bind to User (value type of dict[str, User]). + // Without enumerate() support, v is unbound → resolver emits 0 CALLS. + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve v.save() to a non-User target', () => { + // i is the int index from enumerate — must not produce a spurious CALLS edge + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && !c.targetFilePath?.includes('user.py'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves nested tuple pattern: for i, (k, v) in enumerate(d.items())', () => { + // Nested tuple_pattern inside pattern_list — must descend to find v + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_nested_tuple' && c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves parenthesized tuple: for (i, u) in enumerate(users)', () => { + // tuple_pattern as top-level left node (not pattern_list) + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_parenthesized_tuple' && c.targetFilePath?.includes('user.py'), + ); + expect(userSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution — annotated attribute capture +// --------------------------------------------------------------------------- + +describe('Field type resolution (Python)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'User']); + }); + + it('detects Property nodes for Python annotated attributes', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking attributes to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('Address → city'); + }); + + it('resolves user.address.save() → Address#save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find( + e => e.source === 'process_user' && e.targetFilePath.includes('models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field type disambiguation — both User and Address have save() +// --------------------------------------------------------------------------- + +describe('Field type disambiguation (Python)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-field-type-disambig'), + () => {}, + ); + }, 60000); + + it('detects both User#save and Address#save', () => { + const methods = getNodesByLabel(result, 'Function'); + const saveMethods = methods.filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.address.save() → Address#save (not User#save)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter( + e => e.target === 'save' && e.source === 'process_user', + ); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('address'); + expect(saveCalls[0].targetFilePath).not.toContain('user'); + }); +}); + +// --------------------------------------------------------------------------- +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (Python)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'python-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for attribute assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(2); + const nameWrite = writes.find(e => e.target === 'name'); + const addressWrite = writes.find(e => e.target === 'address'); + expect(nameWrite).toBeDefined(); + expect(nameWrite!.source).toBe('update_user'); + expect(addressWrite).toBeDefined(); + expect(addressWrite!.source).toBe('update_user'); + }); +}); diff --git a/gitnexus/test/integration/resolvers/ruby.test.ts b/gitnexus/test/integration/resolvers/ruby.test.ts new file mode 100644 index 0000000000..ad6f474f71 --- /dev/null +++ b/gitnexus/test/integration/resolvers/ruby.test.ts @@ -0,0 +1,968 @@ +/** + * Ruby: require_relative imports, include heritage (mixins), attr_* properties, + * calls, member calls, ambiguous disambiguation, local shadow, + * constructor-inferred type resolution + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: require_relative imports + include heritage + attr_* properties + calls +// --------------------------------------------------------------------------- + +describe('Ruby require_relative, heritage & property resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-app'), + () => {}, + ); + }, 60000); + + // --- Node detection --- + + it('detects 3 classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual([ + 'BaseModel', 'User', 'UserService', + ]); + }); + + it('detects 3 modules', () => { + expect(getNodesByLabel(result, 'Module')).toEqual(['Cacheable', 'Loggable', 'Serializable']); + }); + + it('detects methods on classes and modules', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('persist'); + expect(methods).toContain('run_validations'); + expect(methods).toContain('greet_user'); + expect(methods).toContain('serialize_data'); + expect(methods).toContain('create_user'); + }); + + it('detects singleton method (def self.factory) as Method', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('factory'); + }); + + it('emits CALLS from singleton method: factory → run_validations', () => { + const calls = getRelationships(result, 'CALLS') + .filter(e => e.source === 'factory' && e.target === 'run_validations'); + expect(calls.length).toBe(1); + expect(calls[0].sourceLabel).toBe('Method'); + }); + + // --- Import resolution via require_relative --- + + it('resolves 5 require_relative imports to IMPORTS edges', () => { + const imports = getRelationships(result, 'IMPORTS'); + const importEdges = edgeSet(imports); + expect(importEdges).toContain('user.rb → base_model.rb'); + expect(importEdges).toContain('user.rb → serializable.rb'); + expect(importEdges).toContain('user.rb → loggable.rb'); + expect(importEdges).toContain('user.rb → cacheable.rb'); + expect(importEdges).toContain('service.rb → user.rb'); + }); + + it('resolves bare require to IMPORTS edge', () => { + const imports = getRelationships(result, 'IMPORTS'); + const bareRequire = imports.find(e => + e.sourceFilePath.includes('base_model.rb') && + e.targetFilePath.includes('serializable.rb') + ); + expect(bareRequire).toBeDefined(); + }); + + // --- Heritage: include → IMPLEMENTS --- + + it('emits IMPLEMENTS edge for include Serializable with reason "include"', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + const edge = implements_.find(e => e.source === 'User' && e.target === 'Serializable'); + expect(edge).toBeDefined(); + expect(edge!.rel.reason).toBe('include'); + }); + + it('emits IMPLEMENTS edge for extend Loggable with reason "extend"', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + const edge = implements_.find(e => e.source === 'User' && e.target === 'Loggable'); + expect(edge).toBeDefined(); + expect(edge!.rel.reason).toBe('extend'); + }); + + it('emits IMPLEMENTS edge for prepend Cacheable with reason "prepend"', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + const edge = implements_.find(e => e.source === 'User' && e.target === 'Cacheable'); + expect(edge).toBeDefined(); + expect(edge!.rel.reason).toBe('prepend'); + }); + + // --- Extends: class inheritance --- + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + const edges = edgeSet(extends_); + expect(edges).toContain('User → BaseModel'); + }); + + // --- Property nodes: attr_accessor, attr_reader, attr_writer --- + + it('creates Property nodes for attr_accessor :id and :created_at', () => { + const props = getNodesByLabel(result, 'Property'); + expect(props).toContain('id'); + expect(props).toContain('created_at'); + }); + + it('creates Property nodes for attr_reader :name and attr_writer :email', () => { + const props = getNodesByLabel(result, 'Property'); + expect(props).toContain('name'); + expect(props).toContain('email'); + }); + + it('emits HAS_PROPERTY from User to attr_reader :name', () => { + const hasProperty = getRelationships(result, 'HAS_PROPERTY'); + const edge = hasProperty.find(e => e.source === 'User' && e.target === 'name'); + expect(edge).toBeDefined(); + }); + + it('emits HAS_PROPERTY from BaseModel to attr_accessor :id', () => { + const hasProperty = getRelationships(result, 'HAS_PROPERTY'); + const edge = hasProperty.find(e => e.source === 'BaseModel' && e.target === 'id'); + expect(edge).toBeDefined(); + }); + + // --- Call resolution: method-level attribution --- + + it('emits method-level CALLS: create_user → persist (member call)', () => { + const calls = getRelationships(result, 'CALLS') + .filter(e => e.source === 'create_user' && e.target === 'persist'); + expect(calls.length).toBe(1); + expect(calls[0].sourceLabel).toBe('Method'); + expect(calls[0].targetLabel).toBe('Method'); + }); + + it('emits method-level CALLS: create_user → greet_user (member call)', () => { + const calls = getRelationships(result, 'CALLS') + .filter(e => e.source === 'create_user' && e.target === 'greet_user'); + expect(calls.length).toBe(1); + expect(calls[0].sourceLabel).toBe('Method'); + expect(calls[0].targetLabel).toBe('Method'); + }); + + it('emits method-level CALLS: greet_user → persist (bare call)', () => { + const calls = getRelationships(result, 'CALLS') + .filter(e => e.source === 'greet_user' && e.target === 'persist'); + expect(calls.length).toBe(1); + }); + + it('emits method-level CALLS: greet_user → serialize_data (bare call)', () => { + const calls = getRelationships(result, 'CALLS') + .filter(e => e.source === 'greet_user' && e.target === 'serialize_data'); + expect(calls.length).toBe(1); + }); + + it('emits method-level CALLS: persist → run_validations (bare call)', () => { + const calls = getRelationships(result, 'CALLS') + .filter(e => e.source === 'persist' && e.target === 'run_validations'); + expect(calls.length).toBe(1); + }); + + // --- Heritage edges point to real graph nodes --- + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + } + }); + + // --- No OVERRIDES edges target Property nodes --- + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Calls: arity-based disambiguation +// --------------------------------------------------------------------------- + +describe('Ruby call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-calls'), + () => {}, + ); + }, 60000); + + it('resolves run_task → write_audit to one_arg.rb via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + const auditCall = calls.find(c => c.target === 'write_audit'); + expect(auditCall).toBeDefined(); + expect(auditCall!.source).toBe('run_task'); + expect(auditCall!.targetFilePath).toContain('one_arg.rb'); + expect(auditCall!.rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('Ruby member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves process_user → persist_record as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'persist_record'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('process_user'); + expect(saveCall!.targetFilePath).toContain('user.rb'); + }); + + it('detects User class and persist_record method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('persist_record'); + }); + + it('emits HAS_METHOD edge from User to persist_record', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'User' && e.target === 'persist_record'); + expect(edge).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: Handler in two dirs, require_relative disambiguates +// --------------------------------------------------------------------------- + +describe('Ruby ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes.filter(n => n === 'Handler').length).toBe(2); + expect(classes).toContain('UserHandler'); + }); + + it('resolves EXTENDS to models/handler.rb (not other/handler.rb)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('UserHandler'); + expect(extends_[0].target).toBe('Handler'); + expect(extends_[0].targetFilePath).toBe('models/handler.rb'); + }); + + it('import edge points to models/ not other/', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(1); + expect(imports[0].targetFilePath).toBe('models/handler.rb'); + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of getRelationships(result, 'EXTENDS')) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + } + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('Ruby local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves run_app → do_work to same-file definition, not the imported one', () => { + const calls = getRelationships(result, 'CALLS'); + const doWorkCall = calls.find(c => c.target === 'do_work' && c.source === 'run_app'); + expect(doWorkCall).toBeDefined(); + expect(doWorkCall!.targetFilePath).toContain('app.rb'); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: user = User.new; user.save → User.save +// --------------------------------------------------------------------------- + +describe('Ruby constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, and AppService classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + expect(getNodesByLabel(result, 'Class')).toContain('AppService'); + }); + + it('detects save on User and Repo, cleanup on all three', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods.filter(m => m === 'save').length).toBe(2); + expect(methods.filter(m => m === 'cleanup').length).toBe(3); + }); + + it('resolves user.save to models/user.rb via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/user.rb'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('process_entities'); + }); + + it('resolves repo.save to models/repo.rb via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'models/repo.rb'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('process_entities'); + }); + + it('emits exactly 2 save CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); + + it('resolves self.process_entities to services/app.rb (unique method)', () => { + const calls = getRelationships(result, 'CALLS'); + const selfCall = calls.find(c => + c.source === 'greet' && c.target === 'process_entities' + ); + expect(selfCall).toBeDefined(); + expect(selfCall!.targetFilePath).toContain('app.rb'); + }); + + it('resolves self.cleanup to services/app.rb, not models/user.rb or models/repo.rb', () => { + const calls = getRelationships(result, 'CALLS'); + const selfCleanup = calls.find(c => + c.source === 'greet' && c.target === 'cleanup' + ); + expect(selfCleanup).toBeDefined(); + expect(selfCleanup!.targetFilePath).toContain('app.rb'); + }); +}); + +// --------------------------------------------------------------------------- +// self.save resolves to enclosing class's own save method +// --------------------------------------------------------------------------- + +describe('Ruby self resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves self.save inside User#process to User#save, not Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('lib/models/user.rb'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: < BaseModel + include Module +// --------------------------------------------------------------------------- + +describe('Ruby parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes plus Serializable module', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + expect(getNodesByLabel(result, 'Module')).toEqual(['Serializable']); + }); + + it('emits EXTENDS edge: User < BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits IMPLEMENTS edge: User includes Serializable', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + const includeEdge = implements_.find(e => e.source === 'User' && e.target === 'Serializable'); + expect(includeEdge).toBeDefined(); + expect(includeEdge!.rel.reason).toBe('include'); + }); +}); + +// --------------------------------------------------------------------------- +// Ruby super: standalone keyword calls same-named method on parent +// --------------------------------------------------------------------------- + +describe('Ruby super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-super-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + }); + + it('emits EXTENDS edge: User < BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('detects save methods on all three classes', () => { + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(3); + }); +}); + +// --------------------------------------------------------------------------- +// Ruby constant constructor: SERVICE = UserService.new; SERVICE.process +// --------------------------------------------------------------------------- + +describe('Ruby constant constructor binding resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-constant-constructor'), + () => {}, + ); + }, 60000); + + it('detects UserService class with process and validate methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + expect(getNodesByLabel(result, 'Method')).toContain('process'); + expect(getNodesByLabel(result, 'Method')).toContain('validate'); + }); + + it('resolves SERVICE.process() via constant constructor binding', () => { + const calls = getRelationships(result, 'CALLS'); + const processCall = calls.find(c => c.target === 'process' && c.targetFilePath === 'models.rb'); + expect(processCall).toBeDefined(); + }); + + it('resolves SERVICE.validate() via constant constructor binding', () => { + const calls = getRelationships(result, 'CALLS'); + const validateCall = calls.find(c => c.target === 'validate' && c.targetFilePath === 'models.rb'); + expect(validateCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// YARD annotation type resolution: @param repo [UserRepo] → repo.save resolves +// --------------------------------------------------------------------------- + +describe('Ruby YARD annotation type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-yard-annotations'), + () => {}, + ); + }, 60000); + + it('detects UserRepo, User, and UserService classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserRepo'); + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + }); + + it('detects save, find_by_name, greet, and create methods', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('save'); + expect(methods).toContain('find_by_name'); + expect(methods).toContain('greet'); + expect(methods).toContain('create'); + }); + + it('resolves repo.save to UserRepo#save via YARD @param annotation', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'create'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toContain('models.rb'); + }); + + it('resolves user.greet to User#greet via YARD @param annotation', () => { + const calls = getRelationships(result, 'CALLS'); + const greetCall = calls.find(c => c.target === 'greet' && c.source === 'create'); + expect(greetCall).toBeDefined(); + expect(greetCall!.targetFilePath).toContain('models.rb'); + }); +}); + +// --------------------------------------------------------------------------- +// Namespaced constructor: svc = Models::UserService.new; svc.process() +// Tests scope_resolution receiver handling for Ruby namespaced classes. +// --------------------------------------------------------------------------- + +describe('Ruby namespaced constructor resolution (Models::UserService.new)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-namespaced-constructor'), + () => {}, + ); + }, 60000); + + it('detects UserService class with process and validate methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('process'); + expect(methods).toContain('validate'); + }); + + it('resolves svc.process() via namespaced constructor Models::UserService.new', () => { + const calls = getRelationships(result, 'CALLS'); + const processCall = calls.find(c => + c.target === 'process' && c.targetFilePath.includes('user_service.rb') + ); + expect(processCall).toBeDefined(); + }); + + it('resolves svc.validate() via namespaced constructor Models::UserService.new', () => { + const calls = getRelationships(result, 'CALLS'); + const validateCall = calls.find(c => + c.target === 'validate' && c.targetFilePath.includes('user_service.rb') + ); + expect(validateCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: user = get_user('alice'); user.save +// Ruby's scanConstructorBinding captures assignment nodes with call RHS. +// Combined with YARD @return annotation parsing, the pipeline resolves +// `user.save` to User#save (not Repo#save) via return type disambiguation. +// The fixture has BOTH User#save and Repo#save — fuzzy matching alone +// cannot disambiguate, so return type inference must be working. +// --------------------------------------------------------------------------- + +describe('Ruby return type inference via function call', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-return-type'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('detects get_user and get_repo methods', () => { + expect(getNodesByLabel(result, 'Method')).toContain('get_user'); + expect(getNodesByLabel(result, 'Method')).toContain('get_repo'); + }); + + it('detects save method on both User and Repo (disambiguation required)', () => { + const methods = getNodesByLabel(result, 'Method'); + // Both classes have save — fuzzy match alone cannot resolve this + expect(methods.filter(m => m === 'save').length).toBe(2); + }); + + it('resolves user.save to User#save via YARD @return [User] on get_user()', () => { + // With both User#save and Repo#save in scope, resolving user.save + // requires return type inference: get_user() → @return [User] → user is User + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_user' && c.targetFilePath.includes('models.rb'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves repo.save to Repo#save via YARD @return [Repo] on get_repo()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_repo' && c.targetFilePath.includes('repo.rb'), + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Ruby constant LHS factory call: SERVICE = build_service() with YARD @return +// Verifies that constant assignments (uppercase LHS) from plain function calls +// are captured by scanConstructorBinding, not just identifier assignments. +// --------------------------------------------------------------------------- + +describe('Ruby constant factory call resolution (SERVICE = build_service())', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-constant-factory-call'), + () => {}, + ); + }, 60000); + + it('detects UserService and AdminService classes with process and validate methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserService'); + expect(getNodesByLabel(result, 'Class')).toContain('AdminService'); + expect(getNodesByLabel(result, 'Method')).toContain('process'); + expect(getNodesByLabel(result, 'Method')).toContain('validate'); + }); + + it('resolves SERVICE.process() to UserService#process via constant factory call', () => { + const calls = getRelationships(result, 'CALLS'); + const processCall = calls.find(c => + c.target === 'process' && c.targetFilePath.includes('user_service.rb'), + ); + expect(processCall).toBeDefined(); + const wrongCall = calls.find(c => + c.target === 'process' && + c.sourceFilePath?.includes('app.rb') && + c.targetFilePath.includes('admin_service.rb'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves SERVICE.validate() to UserService#validate via constant factory call', () => { + const calls = getRelationships(result, 'CALLS'); + const validateCall = calls.find(c => + c.target === 'validate' && c.targetFilePath.includes('user_service.rb'), + ); + expect(validateCall).toBeDefined(); + const wrongCall = calls.find(c => + c.target === 'validate' && + c.sourceFilePath?.includes('app.rb') && + c.targetFilePath.includes('admin_service.rb'), + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +describe('Ruby YARD generic type annotations (Hash<Symbol, User>)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-yard-generics'), + () => {}, + ); + }, 60000); + + it('detects UserRepo, AdminRepo, and DataService classes', () => { + expect(getNodesByLabel(result, 'Class')).toContain('UserRepo'); + expect(getNodesByLabel(result, 'Class')).toContain('AdminRepo'); + expect(getNodesByLabel(result, 'Class')).toContain('DataService'); + }); + + it('detects save and find_all on both repos, plus sync and audit methods', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('save'); + expect(methods).toContain('find_all'); + expect(methods).toContain('sync'); + expect(methods).toContain('audit'); + }); + + it('resolves repo.save in sync() to UserRepo#save via @param repo [UserRepo]', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'sync' && c.targetFilePath.includes('models.rb'), + ); + expect(saveCall).toBeDefined(); + }); + + it('does NOT resolve cache param to a class (Hash<Symbol, UserRepo> is a generic container)', () => { + // The @param cache [Hash<Symbol, UserRepo>] should extract type "Hash" — not "UserRepo". + // Since Hash is not a class in the fixture, no type binding is created for cache. + // This verifies the bracket-balanced split doesn't break on the inner comma. + const calls = getRelationships(result, 'CALLS'); + // No calls should originate from cache.* since cache has no resolved type + const cacheCall = calls.find(c => + c.source === 'sync' && c.target === 'save' && c.targetFilePath.includes('admin'), + ); + expect(cacheCall).toBeUndefined(); + }); + + it('resolves admin_repo.save in audit() to AdminRepo#save via alternate @param [AdminRepo] order', () => { + const calls = getRelationships(result, 'CALLS'); + // audit() calls admin_repo.save — should resolve via the alternate YARD format + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'audit', + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves admin_repo.find_all in audit() to AdminRepo#find_all', () => { + const calls = getRelationships(result, 'CALLS'); + const findCall = calls.find(c => + c.target === 'find_all' && c.source === 'audit', + ); + expect(findCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method calls: svc.get_user.save +// Tests that Ruby's `call` node uses `method` and `receiver` fields correctly +// for chain extraction — the tree-sitter-ruby grammar differs from other languages. +// --------------------------------------------------------------------------- + +describe('Ruby chained method call resolution (Phase 5 review fix)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, UserService and App classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + expect(classes).toContain('App'); + }); + + it('detects save methods on both User and Repo', () => { + const methods = getNodesByLabel(result, 'Method'); + const saveMethods = methods.filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('detects get_user method on UserService', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('get_user'); + }); + + it('resolves svc.get_user.save to User#save via chain resolution', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'process' && + c.targetFilePath?.includes('user.rb'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.get_user.save to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'process' && + c.targetFilePath?.includes('repo.rb'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Ruby for-in loop: for user in users — YARD @param resolution +// --------------------------------------------------------------------------- + +describe('Ruby for-in loop resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-for-in-loop'), + () => {}, + ); + }, 60000); + + it('detects User class with save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves user.save in for-in to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('user'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution via YARD @return annotations +// --------------------------------------------------------------------------- + +describe('Field type resolution (Ruby)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'User']); + }); + + it('detects Property nodes for attr_accessor fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking properties to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('Address → city'); + }); + + it('resolves user.address.save → Address#save via YARD @return [Address]', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find( + e => e.source === 'process_user' && e.targetFilePath.includes('models'), + ); + expect(addressSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field type disambiguation — both User and Address have save() +// --------------------------------------------------------------------------- + +describe('Field type disambiguation (Ruby)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-field-type-disambig'), + () => {}, + ); + }, 60000); + + it('detects both User#save and Address#save', () => { + const methods = getNodesByLabel(result, 'Method'); + const saveMethods = methods.filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.address.save → Address#save (not User#save)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter( + e => e.target === 'save' && e.source === 'process_user', + ); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('address'); + expect(saveCalls[0].targetFilePath).not.toContain('user'); + }); +}); + +// --------------------------------------------------------------------------- +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (Ruby)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ruby-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for setter assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(3); + const nameWrite = writes.find(e => e.target === 'name'); + const addressWrite = writes.find(e => e.target === 'address'); + const scoreWrite = writes.find(e => e.target === 'score'); + expect(nameWrite).toBeDefined(); + expect(nameWrite!.source).toBe('update_user'); + expect(addressWrite).toBeDefined(); + expect(addressWrite!.source).toBe('update_user'); + expect(scoreWrite).toBeDefined(); + expect(scoreWrite!.source).toBe('update_user'); + }); + + it('emits ACCESSES write edge for compound assignment (operator_assignment)', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + const scoreWrite = writes.find(e => e.target === 'score'); + expect(scoreWrite).toBeDefined(); + expect(scoreWrite!.source).toBe('update_user'); + }); + + it('write ACCESSES edges have confidence 1.0', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + for (const edge of writes) { + expect(edge.rel.confidence).toBe(1.0); + } + }); +}); diff --git a/gitnexus/test/integration/resolvers/rust.test.ts b/gitnexus/test/integration/resolvers/rust.test.ts new file mode 100644 index 0000000000..e5b0e1d057 --- /dev/null +++ b/gitnexus/test/integration/resolvers/rust.test.ts @@ -0,0 +1,1431 @@ +/** + * Rust: trait implementations + ambiguous module import disambiguation + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: trait implementations +// --------------------------------------------------------------------------- + +describe('Rust trait implementation resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-traits'), + () => {}, + ); + }, 60000); + + it('detects exactly 1 struct and 2 traits', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['Button']); + expect(getNodesByLabel(result, 'Trait')).toEqual(['Clickable', 'Drawable']); + }); + + it('emits exactly 2 IMPLEMENTS edges with reason trait-impl', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(2); + expect(edgeSet(implements_)).toEqual([ + 'Button → Clickable', + 'Button → Drawable', + ]); + for (const edge of implements_) { + expect(edge.rel.reason).toBe('trait-impl'); + } + }); + + it('does not emit any EXTENDS edges for trait impls', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(0); + }); + + it('resolves exactly 1 IMPORTS edge: main.rs → button.rs', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(1); + expect(imports[0].source).toBe('main.rs'); + expect(imports[0].target).toBe('button.rs'); + }); + + it('detects 2 modules and 4 functions', () => { + expect(getNodesByLabel(result, 'Module')).toEqual(['impls', 'traits']); + expect(getNodesByLabel(result, 'Function')).toEqual(['draw', 'is_enabled', 'main', 'on_click', 'resize']); + }); + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: Handler struct in two modules, crate:: import disambiguates +// --------------------------------------------------------------------------- + +describe('Rust ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects 2 Handler structs in separate modules', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(`${n.properties.name}@${n.properties.filePath}`); + }); + const handlers = structs.filter(s => s.startsWith('Handler@')); + expect(handlers.length).toBe(2); + expect(handlers.some(h => h.includes('src/models/'))).toBe(true); + expect(handlers.some(h => h.includes('src/other/'))).toBe(true); + }); + + it('import resolves to src/models/mod.rs (not src/other/mod.rs)', () => { + const imports = getRelationships(result, 'IMPORTS'); + const modelsImport = imports.find(e => e.targetFilePath.includes('models')); + expect(modelsImport).toBeDefined(); + expect(modelsImport!.targetFilePath).toBe('src/models/mod.rs'); + }); + + it('no import edge to src/other/', () => { + const imports = getRelationships(result, 'IMPORTS'); + for (const imp of imports) { + expect(imp.targetFilePath).not.toMatch(/src\/other\//); + } + }); +}); + +describe('Rust call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-calls'), + () => {}, + ); + }, 60000); + + it('resolves main → write_audit to src/onearg/mod.rs via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('main'); + expect(calls[0].target).toBe('write_audit'); + expect(calls[0].targetFilePath).toBe('src/onearg/mod.rs'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('Rust member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves process_user → save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('process_user'); + expect(saveCall!.targetFilePath).toBe('src/user.rs'); + }); + + it('detects User struct and save function (Rust impl fns are Function nodes)', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(n.properties.name); + }); + expect(structs).toContain('User'); + // Rust tree-sitter captures all function_item as Function, including impl methods + expect(getNodesByLabel(result, 'Function')).toContain('save'); + }); +}); + +// --------------------------------------------------------------------------- +// Struct literal resolution: User { ... } resolves to Struct node +// --------------------------------------------------------------------------- + +describe('Rust struct literal resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-struct-literals'), + () => {}, + ); + }, 60000); + + it('resolves User { ... } as a CALLS edge to the User struct', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.source).toBe('process_user'); + expect(ctorCall!.targetLabel).toBe('Struct'); + expect(ctorCall!.targetFilePath).toBe('user.rs'); + expect(ctorCall!.rel.reason).toBe('import-resolved'); + }); + + it('also resolves user.save() as a member call', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('process_user'); + }); + + it('detects User struct and process_user function', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(n.properties.name); + }); + expect(structs).toContain('User'); + expect(getNodesByLabel(result, 'Function')).toContain('process_user'); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed variables disambiguate same-named methods +// --------------------------------------------------------------------------- + +describe('Rust receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, both with save functions', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(n.properties.name); + }); + expect(structs).toContain('User'); + expect(structs).toContain('Repo'); + // Rust tree-sitter captures impl fns as Function nodes + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() to User.save and repo.save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'src/user.rs'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'src/repo.rs'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('process_entities'); + expect(repoSave!.source).toBe('process_entities'); + }); +}); + +// --------------------------------------------------------------------------- +// Alias import resolution: use crate::models::User as U resolves U → User +// --------------------------------------------------------------------------- + +describe('Rust alias import resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-alias-imports'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with their methods', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(n.properties.name); + }); + expect(structs).toContain('User'); + expect(structs).toContain('Repo'); + expect(getNodesByLabel(result, 'Function')).toContain('save'); + expect(getNodesByLabel(result, 'Function')).toContain('persist'); + }); + + it('resolves u.save() to src/models.rs and r.persist() to src/models.rs via alias', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + const persistCall = calls.find(c => c.target === 'persist'); + + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + expect(saveCall!.targetFilePath).toBe('src/models.rs'); + + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('main'); + expect(persistCall!.targetFilePath).toBe('src/models.rs'); + }); + + it('emits exactly 1 IMPORTS edge: src/main.rs → src/models.rs', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(1); + expect(imports[0].sourceFilePath).toBe('src/main.rs'); + expect(imports[0].targetFilePath).toBe('src/models.rs'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// Re-export chain: pub use in mod.rs followed through to definition file +// --------------------------------------------------------------------------- + +describe('Rust re-export chain resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-reexport-chain'), + () => {}, + ); + }, 60000); + + it('detects Handler struct in handler.rs', () => { + const structs: string[] = []; + result.graph.forEachNode(n => { + if (n.label === 'Struct') structs.push(`${n.properties.name}@${n.properties.filePath}`); + }); + expect(structs).toContain('Handler@src/models/handler.rs'); + }); + + it('resolves Handler { ... } to src/models/handler.rs via re-export chain, not mod.rs', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'Handler'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.source).toBe('main'); + expect(ctorCall!.targetLabel).toBe('Struct'); + expect(ctorCall!.targetFilePath).toBe('src/models/handler.rs'); + }); + + it('resolves h.process() to src/models/handler.rs', () => { + const calls = getRelationships(result, 'CALLS'); + const processCall = calls.find(c => c.target === 'process'); + expect(processCall).toBeDefined(); + expect(processCall!.source).toBe('main'); + expect(processCall!.targetFilePath).toBe('src/models/handler.rs'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('Rust local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves run → save to same-file definition, not the imported one', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'run'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/main.rs'); + }); + + it('does NOT resolve save to utils.rs', () => { + const calls = getRelationships(result, 'CALLS'); + const saveToUtils = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/utils.rs'); + expect(saveToUtils).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Grouped imports: use crate::helpers::{func_a, func_b} +// Verifies no spurious binding for the path prefix (e.g. "helpers") +// --------------------------------------------------------------------------- + +describe('Rust grouped import resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-grouped-imports'), + () => {}, + ); + }, 60000); + + it('resolves main → format_name to src/helpers/mod.rs', () => { + const calls = getRelationships(result, 'CALLS'); + const call = calls.find(c => c.target === 'format_name'); + expect(call).toBeDefined(); + expect(call!.source).toBe('main'); + expect(call!.targetFilePath).toBe('src/helpers/mod.rs'); + expect(call!.rel.reason).toBe('import-resolved'); + }); + + it('resolves main → validate_email to src/helpers/mod.rs', () => { + const calls = getRelationships(result, 'CALLS'); + const call = calls.find(c => c.target === 'validate_email'); + expect(call).toBeDefined(); + expect(call!.source).toBe('main'); + expect(call!.targetFilePath).toBe('src/helpers/mod.rs'); + expect(call!.rel.reason).toBe('import-resolved'); + }); + + it('does not create a spurious CALLS edge for the path prefix "helpers"', () => { + const calls = getRelationships(result, 'CALLS'); + const spurious = calls.find(c => c.target === 'helpers' || c.source === 'helpers'); + expect(spurious).toBeUndefined(); + }); + + it('emits exactly 1 IMPORTS edge: main.rs → helpers/mod.rs', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(1); + expect(imports[0].source).toBe('main.rs'); + expect(imports[0].target).toBe('mod.rs'); + expect(imports[0].targetFilePath).toBe('src/helpers/mod.rs'); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: let user = User::new(); user.save() +// Rust scoped_identifier constructor pattern (no explicit type annotations) +// --------------------------------------------------------------------------- + +describe('Rust constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, both with save methods', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() to src/user.rs via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/user.rs'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('process_entities'); + }); + + it('resolves repo.save() to src/repo.rs via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/repo.rs'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('process_entities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// self.save() resolves to enclosing impl's own save method +// --------------------------------------------------------------------------- + +describe('Rust self resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, each with a save function', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves self.save() inside User::process to User::save, not Repo::save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/user.rs'); + }); +}); + +// --------------------------------------------------------------------------- +// Trait impl emits IMPLEMENTS edge +// --------------------------------------------------------------------------- + +describe('Rust parent resolution (trait impl)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects User struct and Serializable trait', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Trait')).toContain('Serializable'); + }); + + it('emits IMPLEMENTS edge: User → Serializable (trait impl)', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('User'); + expect(implements_[0].target).toBe('Serializable'); + expect(implements_[0].rel.reason).toBe('trait-impl'); + }); + + it('no EXTENDS edges (Rust has no class inheritance)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(0); + }); +}); + +// --------------------------------------------------------------------------- +// Struct literal inference: let user = User { ... }; user.save() +// --------------------------------------------------------------------------- + +describe('Rust struct literal type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-struct-literal-inference'), + () => {}, + ); + }, 60000); + + it('resolves user.save() via struct literal inference (User { ... })', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.targetFilePath === 'models.rs'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + }); + + it('resolves config.validate() via struct literal inference (Config { ... })', () => { + const calls = getRelationships(result, 'CALLS'); + const validateCall = calls.find(c => c.target === 'validate' && c.targetFilePath === 'models.rs'); + expect(validateCall).toBeDefined(); + expect(validateCall!.source).toBe('main'); + }); +}); + +// --------------------------------------------------------------------------- +// Rust Self {} struct literal: Self resolves to enclosing impl type +// --------------------------------------------------------------------------- + +describe('Rust Self {} struct literal resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-self-struct-literal'), + () => {}, + ); + }, 60000); + + it('resolves fresh.validate() inside impl User via Self {} inference', () => { + const calls = getRelationships(result, 'CALLS'); + const validateCall = calls.find(c => c.target === 'validate' && c.source === 'blank'); + expect(validateCall).toBeDefined(); + expect(validateCall!.targetFilePath).toBe('models.rs'); + }); +}); + +// --------------------------------------------------------------------------- +// if let / while let: captured_pattern type extraction +// Extracts type from `user @ User { .. }` patterns in if-let/while-let +// --------------------------------------------------------------------------- + +describe('Rust if-let captured_pattern type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-if-let'), + () => {}, + ); + }, 60000); + + it('detects User and Config structs with their methods', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Config'); + expect(getNodesByLabel(result, 'Function')).toContain('save'); + expect(getNodesByLabel(result, 'Function')).toContain('validate'); + }); + + it('resolves user.save() inside if-let via captured_pattern binding', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process_if_let'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('models.rs'); + }); + + it('resolves cfg.validate() inside while-let via captured_pattern binding', () => { + const calls = getRelationships(result, 'CALLS'); + const validateCall = calls.find(c => c.target === 'validate' && c.source === 'process_while_let'); + expect(validateCall).toBeDefined(); + expect(validateCall!.targetFilePath).toBe('models.rs'); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: let user = get_user("alice"); user.save() +// Plain function call (no ::new) with no type annotation +// --------------------------------------------------------------------------- + +describe('Rust return type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-return-type'), + () => {}, + ); + }, 60000); + + it('detects User struct and get_user + save functions', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Function')).toContain('get_user'); + expect(getNodesByLabel(result, 'Function')).toContain('save'); + }); + + it('resolves main → get_user as a CALLS edge to src/models.rs', () => { + const calls = getRelationships(result, 'CALLS'); + const getUserCall = calls.find(c => c.target === 'get_user' && c.source === 'main'); + expect(getUserCall).toBeDefined(); + expect(getUserCall!.targetFilePath).toBe('src/models.rs'); + }); + + it('resolves user.save() to src/models.rs via return-type-inferred binding', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'main'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/models.rs'); + }); +}); + +// --------------------------------------------------------------------------- +// Return-type inference with competing methods: +// Two structs both have save(), factory functions disambiguate via return type +// --------------------------------------------------------------------------- + +describe('Rust return-type inference via function return type', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-return-type-inference'), + () => {}, + ); + }, 60000); + + it('resolves user.save() to models.rs User#save via return type of get_user()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_user' && c.targetFilePath.includes('models') + ); + expect(saveCall).toBeDefined(); + }); + + it('user.save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_user' + ); + // Should resolve to exactly one target — if it resolves at all, check it's the right one + if (wrongSave) { + expect(wrongSave.targetFilePath).toContain('models'); + } + }); + + it('resolves repo.save() to models.rs Repo#save via return type of get_repo()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_repo' && c.targetFilePath.includes('models') + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Rust ::default() constructor resolution — scanner exclusion +// --------------------------------------------------------------------------- + +describe('Rust ::default() constructor resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-default-constructor'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs', () => { + const structs = getNodesByLabel(result, 'Struct'); + expect(structs).toContain('User'); + expect(structs).toContain('Repo'); + }); + + it('detects save methods on both structs', () => { + const methods = [...getNodesByLabel(result, 'Function'), ...getNodesByLabel(result, 'Method')]; + expect(methods.filter((m: string) => m === 'save').length).toBe(2); + }); + + it('resolves user.save() in process_with_new() via User::new() constructor', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_with_new' && c.targetFilePath.includes('user.rs'), + ); + expect(saveCall).toBeDefined(); + }); + + it('resolves user.save() in process_with_default() via User::default() constructor', () => { + // User::default() should be resolved by extractInitializer (Tier 1), + // NOT by the scanner — the scanner excludes ::default() to avoid + // wasted cross-file lookups on the broadly-implemented Default trait + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_with_default' && c.targetFilePath.includes('user.rs'), + ); + expect(saveCall).toBeDefined(); + }); + + it('disambiguates repo.save() in process_with_default() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process_with_default' && c.targetFilePath.includes('repo.rs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-contaminate (user.save() does not resolve to Repo#save)', () => { + const calls = getRelationships(result, 'CALLS'); + // In process_with_new: user.save() should go to user.rs, not repo.rs + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'process_with_new' && c.targetFilePath.includes('repo.rs'), + ); + // Either undefined (correctly disambiguated) or present (both resolved) — no single wrong one + if (wrongCall) { + // If both are present, there should also be a correct one + const correctCall = calls.find(c => + c.target === 'save' && c.source === 'process_with_new' && c.targetFilePath.includes('user.rs'), + ); + expect(correctCall).toBeDefined(); + } + }); +}); + +// --------------------------------------------------------------------------- +// Rust async .await constructor binding resolution +// Verifies that `let user = create_user().await` correctly unwraps the +// await_expression to find the call_expression underneath, producing a +// constructor binding that enables receiver-based disambiguation of user.save(). +// --------------------------------------------------------------------------- + +describe('Rust async .await constructor binding resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-async-binding'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs', () => { + const structs = getNodesByLabel(result, 'Struct'); + expect(structs).toContain('User'); + expect(structs).toContain('Repo'); + }); + + it('detects save methods in separate files', () => { + const methods = [...getNodesByLabel(result, 'Function'), ...getNodesByLabel(result, 'Method')]; + expect(methods.filter((m: string) => m === 'save').length).toBe(2); + }); + + it('resolves user.save() after .await to user.rs via return type of get_user()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_user' && c.targetFilePath.includes('user'), + ); + expect(saveCall).toBeDefined(); + }); + + it('user.save() does NOT resolve to Repo#save in repo.rs', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_user' && c.targetFilePath.includes('repo'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves repo.save() after .await to repo.rs via return type of get_repo()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'process_repo' && c.targetFilePath.includes('repo'), + ); + expect(saveCall).toBeDefined(); + }); + + it('repo.save() does NOT resolve to User#save in user.rs', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_repo' && c.targetFilePath.includes('user'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable receiver: let user: Option<User> = find_user(); user.unwrap().save() +// Rust Option<User> — stripNullable unwraps Option wrapper to inner type. +// --------------------------------------------------------------------------- + +describe('Rust nullable receiver resolution (Option<T>)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, both with save functions', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.unwrap().save() to User#save via Option<User> unwrapping', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'process_entities' && + c.targetFilePath?.includes('user'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.unwrap().save() to Repo#save via Option<Repo> unwrapping', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'process_entities' && + c.targetFilePath?.includes('repo'), + ); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Assignment chain propagation (Phase 4.3) +// --------------------------------------------------------------------------- + +describe('Rust assignment chain propagation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs each with a save function', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves alias.save() to User#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_entities' && c.targetFilePath?.includes('user.rs'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves r_alias.save() to Repo#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process_entities' && c.targetFilePath?.includes('repo.rs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('alias.save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save' && c.source === 'process_entities'); + expect(saveCalls.filter(c => c.targetFilePath?.includes('user.rs')).length).toBe(1); + expect(saveCalls.filter(c => c.targetFilePath?.includes('repo.rs')).length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// Rust Option<User> receiver resolution — extractSimpleTypeName unwraps +// Option<User> to "User" via NULLABLE_WRAPPER_TYPES. The variable declared +// as Option<User> now stores "User" in TypeEnv, enabling direct receiver +// disambiguation without chained .unwrap() inference. +// --------------------------------------------------------------------------- + +describe('Rust Option<User> receiver resolution via wrapper unwrapping', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-option-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs each with a save function', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves alias.save() to User#save via Option<User> → assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_entities' && c.targetFilePath?.includes('user.rs'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() to Repo#save alongside Option usage', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process_entities' && c.targetFilePath?.includes('repo.rs'), + ); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// if let Some(user) = opt — Phase 5.2 pattern binding: unwrap Option<T> +// `opt: Option<User>` → Option<User> is stored as "User" in TypeEnv via +// NULLABLE_WRAPPER_TYPES. extractPatternBinding maps `user` → "User". +// Disambiguation: User.save vs Repo.save — only User.save should be called. +// --------------------------------------------------------------------------- + +describe('Rust if-let Some(x) = opt pattern binding (Phase 5.2)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-if-let-unwrap'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs each with a save function', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() inside if-let Some(user) = opt to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'process' && + c.targetFilePath?.includes('user.rs'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'process' && + c.targetFilePath?.includes('repo.rs'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Rust if-let Err(e) = res pattern binding (Phase 5 review fix) +// Result<User, AppError> → Err(e) should type e as AppError (typeArgs[1]). +// Also tests Ok(user) in the same fixture to verify both arms work. +// --------------------------------------------------------------------------- + +describe('Rust if-let Err(e) pattern binding (Phase 5 review fix)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-err-unwrap'), + () => {}, + ); + }, 60000); + + it('detects User and AppError structs', () => { + const structs = getNodesByLabel(result, 'Struct'); + expect(structs).toContain('User'); + expect(structs).toContain('AppError'); + }); + + it('resolves e.report() inside if-let Err(e) to AppError#report', () => { + const calls = getRelationships(result, 'CALLS'); + const reportCall = calls.find(c => + c.target === 'report' && + c.source === 'handle_err' && + c.targetFilePath?.includes('error.rs'), + ); + expect(reportCall).toBeDefined(); + }); + + it('resolves user.save() inside if-let Ok(user) to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && + c.source === 'handle_ok' && + c.targetFilePath?.includes('user.rs'), + ); + expect(saveCall).toBeDefined(); + }); + + it('does NOT resolve e.report() to User#save (no cross-contamination)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && + c.source === 'handle_err', + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method calls: svc.get_user().save() +// Tests that Rust chain call resolution correctly infers the intermediate +// receiver type from get_user()'s return type and resolves save() to User. +// --------------------------------------------------------------------------- + +describe('Rust chained method call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs, and UserService', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + expect(getNodesByLabel(result, 'Struct')).toContain('UserService'); + }); + + it('detects get_user and save functions', () => { + const fns = getNodesByLabel(result, 'Function'); + expect(fns).toContain('get_user'); + expect(fns).toContain('save'); + }); + + it('resolves svc.get_user().save() to User#save via chain resolution', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'process_user' && + c.targetFilePath?.includes('user.rs'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.get_user().save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'process_user' && + c.targetFilePath?.includes('repo.rs'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Rust for-loop Tier 1c: for user in &users with Vec<User> parameter +// --------------------------------------------------------------------------- + +describe('Rust for-loop type resolution (Tier 1c)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-for-loop'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with save functions', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() in for-loop to User#save via Tier 1c', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('user.rs'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('repo.rs'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves repo.save() in for-loop to Repo#save via Tier 1c', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process_repos' && c.targetFilePath?.includes('repo.rs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT resolve repo.save() to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_repos' && c.targetFilePath?.includes('user.rs'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Rust match arm: match opt { Some(user) => user.save() } +// --------------------------------------------------------------------------- + +describe('Rust match arm type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-match-unwrap'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with save functions', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() inside match Some(user) to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath?.includes('user.rs'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save() in match to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath?.includes('repo.rs'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('resolves repo.save() inside if-let Ok(repo) to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'check' && c.targetFilePath?.includes('repo.rs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT resolve repo.save() in if-let to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'check' && c.targetFilePath?.includes('user.rs'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// for user in users.iter() — call_expression iterable resolution +// --------------------------------------------------------------------------- + +describe('Rust .iter() for-loop call_expression resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-iter-for-loop'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with save functions', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() via users.iter() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('user.rs'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() via repos.into_iter() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process_repos' && c.targetFilePath?.includes('repo.rs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('repo.rs'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// for user in get_users() — direct call_expression iterable resolution +// Phase 7.3: unlike rust-iter-for-loop (typed variable .iter()), this tests +// iterating over a function call's return value directly. +// --------------------------------------------------------------------------- + +describe('Rust for-loop direct call_expression iterable resolution (Phase 7.3)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-for-call-expr'), + () => {}, + ); + }, 60000); + + it('detects User and Repo structs with competing save functions', () => { + expect(getNodesByLabel(result, 'Struct')).toContain('User'); + expect(getNodesByLabel(result, 'Struct')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(f => f === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() in for-loop over get_users() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('user.rs'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in for-loop over get_repos() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'process_repos' && c.targetFilePath?.includes('repo.rs'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_users' && c.targetFilePath?.includes('repo.rs'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('does NOT resolve repo.save() to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process_repos' && c.targetFilePath?.includes('user.rs'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution — struct field capture +// --------------------------------------------------------------------------- + +describe('Field type resolution (Rust)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-field-types'), + () => {}, + ); + }, 60000); + + it('detects structs: Address, User', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['Address', 'User']); + }); + + it('detects Property nodes for Rust struct fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking fields to structs', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(3); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('Address → city'); + }); + + it('resolves user.address.save() → Address#save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter( + e => e.target === 'save' && e.source === 'process_user', + ); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('models'); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8B: Deep field chain resolution (3-level) +// --------------------------------------------------------------------------- + +describe('Deep field chain resolution (Rust)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-deep-field-chain'), + () => {}, + ); + }, 60000); + + it('detects structs: Address, City, User', () => { + expect(getNodesByLabel(result, 'Struct')).toEqual(['Address', 'City', 'User']); + }); + + it('detects Property nodes for Rust struct fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('city'); + expect(properties).toContain('zip_code'); + }); + + it('emits HAS_PROPERTY edges for nested type chain', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(5); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('Address → city'); + expect(edgeSet(propEdges)).toContain('Address → street'); + expect(edgeSet(propEdges)).toContain('City → zip_code'); + }); + + it('resolves 2-level chain: user.address.save() → Address#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'process_user'); + const addressSave = saveCalls.find(e => e.targetFilePath.includes('models')); + expect(addressSave).toBeDefined(); + }); + + it('resolves 3-level chain: user.address.city.get_name() → City#get_name', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'get_name' && e.source === 'process_user'); + const cityGetName = getNameCalls.find(e => e.targetFilePath.includes('models')); + expect(cityGetName).toBeDefined(); + }); +}); + +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (Rust)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'rust-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for field assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(3); + const fieldNames = writes.map(e => e.target); + expect(fieldNames).toContain('name'); + expect(fieldNames).toContain('address'); + expect(fieldNames).toContain('score'); + const sources = writes.map(e => e.source); + expect(sources).toContain('update_user'); + }); + + it('write ACCESSES edges have confidence 1.0', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + for (const edge of writes) { + expect(edge.rel.confidence).toBe(1.0); + } + }); + + it('emits ACCESSES write edge for compound assignment', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + const scoreWrite = writes.find(e => e.target === 'score'); + expect(scoreWrite).toBeDefined(); + expect(scoreWrite!.source).toBe('update_user'); + }); +}); diff --git a/gitnexus/test/integration/resolvers/swift.test.ts b/gitnexus/test/integration/resolvers/swift.test.ts new file mode 100644 index 0000000000..773323044c --- /dev/null +++ b/gitnexus/test/integration/resolvers/swift.test.ts @@ -0,0 +1,226 @@ +/** + * Swift: constructor-inferred type resolution for member calls. + * Verifies that `let user = User(name: "alice"); user.save()` resolves to User.save + * without explicit type annotations, using SymbolTable verification. + * + * NOTE: tree-sitter-swift has build issues on Node 22 — these tests skip gracefully + * when the Swift parser is not available. + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; +import { isLanguageAvailable } from '../../../src/core/tree-sitter/parser-loader.js'; +import { SupportedLanguages } from '../../../src/config/supported-languages.js'; + +const swiftAvailable = isLanguageAvailable(SupportedLanguages.Swift); + +describe.skipIf(!swiftAvailable)('Swift constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'swift-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves user.save() to Models/User.swift via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'Models/User.swift'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.save() to Models/Repo.swift via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'Models/Repo.swift'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// self.save() resolves to enclosing class's own save method +// Build-dep issue (NOT a feature gap): tree-sitter-swift has build issues on Node 22. +// The self/super resolution code already exists in type-env.ts lookupInEnv (lines 56-66). +// --------------------------------------------------------------------------- + +describe.skip('Swift self resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'swift-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a save function', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveFns = getNodesByLabel(result, 'Function').filter(m => m === 'save'); + expect(saveFns.length).toBe(2); + }); + + it('resolves self.save() inside User.process to User.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('Sources/Models/User.swift'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS + protocol conformance +// Build-dep issue (NOT a feature gap): tree-sitter-swift has build issues on Node 22. +// findEnclosingParentClassName in type-env.ts already has Swift inheritance_specifier handler. +// --------------------------------------------------------------------------- + +describe.skip('Swift parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'swift-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes plus Serializable protocol', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['Serializable']); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + const extendsEdge = extends_.find(e => e.source === 'User' && e.target === 'BaseModel'); + expect(extendsEdge).toBeDefined(); + }); + + it('emits IMPLEMENTS edge: User → Serializable (protocol conformance)', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + const implEdge = implements_.find(e => e.source === 'User' && e.target === 'Serializable'); + expect(implEdge).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Swift cross-file User.init() type inference +// --------------------------------------------------------------------------- + +describe.skipIf(!swiftAvailable)('Swift cross-file User.init() inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'swift-init-cross-file'), + () => {}, + ); + }, 60000); + + it('resolves user.save() via User.init(name:) inference', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.targetFilePath === 'User.swift'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + }); + + it('resolves user.greet() via User.init(name:) inference', () => { + const calls = getRelationships(result, 'CALLS'); + const greetCall = calls.find(c => c.target === 'greet' && c.targetFilePath === 'User.swift'); + expect(greetCall).toBeDefined(); + expect(greetCall!.source).toBe('main'); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: let user = getUser(name: "alice"); user.save() +// Swift's CONSTRUCTOR_BINDING_SCANNER captures property_declaration with +// call_expression values, enabling return type inference from function results. +// --------------------------------------------------------------------------- + +describe.skipIf(!swiftAvailable)('Swift return type inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'swift-return-type'), + () => {}, + ); + }, 60000); + + it('detects User class and getUser function', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Function')).toContain('getUser'); + }); + + it('detects save function on User (Swift class methods are Function nodes)', () => { + expect(getNodesByLabel(result, 'Function')).toContain('save'); + }); + + it('resolves user.save() to User#save via return type of getUser() -> User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('Models.swift'), + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Return-type inference with competing methods: +// Two classes both have save(), factory functions disambiguate via return type +// --------------------------------------------------------------------------- + +describe.skipIf(!swiftAvailable)('Swift return-type inference via function return type', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'swift-return-type-inference'), + () => {}, + ); + }, 60000); + + it('resolves user.save() to User#save via return type of getUser()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('Models.swift') + ); + expect(saveCall).toBeDefined(); + }); + + it('user.save() does NOT resolve to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUser' + ); + // Should resolve to exactly one target — if it resolves at all, check it's the right one + if (wrongSave) { + expect(wrongSave.targetFilePath).toContain('Models.swift'); + } + }); + + it('resolves repo.save() to Repo#save via return type of getRepo()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath.includes('Models.swift') + ); + expect(saveCall).toBeDefined(); + }); +}); diff --git a/gitnexus/test/integration/resolvers/typescript.test.ts b/gitnexus/test/integration/resolvers/typescript.test.ts new file mode 100644 index 0000000000..55a19ef764 --- /dev/null +++ b/gitnexus/test/integration/resolvers/typescript.test.ts @@ -0,0 +1,1961 @@ +/** + * TypeScript: heritage resolution + ambiguous symbol disambiguation + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { + FIXTURES, getRelationships, getNodesByLabel, edgeSet, + runPipelineFromRepo, type PipelineResult, +} from './helpers.js'; + +// --------------------------------------------------------------------------- +// Heritage: class extends + implements interface +// --------------------------------------------------------------------------- + +describe('TypeScript heritage resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-ambiguous'), + () => {}, + ); + }, 60000); + + it('detects exactly 3 classes and 1 interface', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseService', 'ConsoleLogger', 'UserService']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['ILogger']); + }); + + it('emits exactly 3 IMPORTS edges', () => { + const imports = getRelationships(result, 'IMPORTS'); + expect(imports.length).toBe(3); + expect(edgeSet(imports)).toEqual([ + 'logger.ts → models.ts', + 'service.ts → logger.ts', + 'service.ts → models.ts', + ]); + }); + + it('emits exactly 1 EXTENDS edge: UserService → BaseService', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('UserService'); + expect(extends_[0].target).toBe('BaseService'); + }); + + it('emits exactly 2 IMPLEMENTS edges', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(2); + expect(edgeSet(implements_)).toEqual([ + 'ConsoleLogger → ILogger', + 'UserService → ILogger', + ]); + }); + + it('emits HAS_METHOD edges linking methods to classes', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + expect(hasMethod.length).toBe(4); + expect(edgeSet(hasMethod)).toEqual([ + 'BaseService → getName', + 'ConsoleLogger → log', + 'UserService → getUsers', + 'UserService → log', + ]); + }); + + it('emits HAS_PROPERTY edge for class fields', () => { + const hasProperty = getRelationships(result, 'HAS_PROPERTY'); + expect(hasProperty.length).toBe(1); + expect(edgeSet(hasProperty)).toEqual(['BaseService → name']); + }); + + it('no OVERRIDES edges target Property nodes', () => { + const overrides = getRelationships(result, 'OVERRIDES'); + for (const edge of overrides) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.label).not.toBe('Property'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Ambiguous: multiple definitions, imports disambiguate +// --------------------------------------------------------------------------- + +describe('TypeScript ambiguous symbol resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-ambiguous'), + () => {}, + ); + }, 60000); + + it('UserService has exactly 1 EXTENDS + 1 IMPLEMENTS', () => { + const extends_ = getRelationships(result, 'EXTENDS').filter(e => e.source === 'UserService'); + const implements_ = getRelationships(result, 'IMPLEMENTS').filter(e => e.source === 'UserService'); + expect(extends_.length).toBe(1); + expect(implements_.length).toBe(1); + }); + + it('ConsoleLogger has exactly 1 IMPLEMENTS and 0 EXTENDS', () => { + const extends_ = getRelationships(result, 'EXTENDS').filter(e => e.source === 'ConsoleLogger'); + const implements_ = getRelationships(result, 'IMPLEMENTS').filter(e => e.source === 'ConsoleLogger'); + expect(extends_.length).toBe(0); + expect(implements_.length).toBe(1); + expect(implements_[0].target).toBe('ILogger'); + }); + + it('all heritage edges point to real graph nodes', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + const implements_ = getRelationships(result, 'IMPLEMENTS'); + + for (const edge of [...extends_, ...implements_]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +describe('TypeScript call resolution with arity filtering', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-calls'), + () => {}, + ); + }, 60000); + + it('resolves run → writeAudit to src/one.ts via arity narrowing', () => { + const calls = getRelationships(result, 'CALLS'); + expect(calls.length).toBe(1); + expect(calls[0].source).toBe('run'); + expect(calls[0].target).toBe('writeAudit'); + expect(calls[0].targetFilePath).toBe('src/one.ts'); + expect(calls[0].rel.reason).toBe('import-resolved'); + }); +}); + +// --------------------------------------------------------------------------- +// Member-call resolution: obj.method() resolves through pipeline +// --------------------------------------------------------------------------- + +describe('TypeScript member-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-member-calls'), + () => {}, + ); + }, 60000); + + it('resolves processUser → save as a member call on User', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + expect(saveCall!.targetFilePath).toBe('src/user.ts'); + }); + + it('detects User class and save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('emits HAS_METHOD edge from User to save', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const edge = hasMethod.find(e => e.source === 'User' && e.target === 'save'); + expect(edge).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor resolution: new Foo() resolves to Class/Constructor +// --------------------------------------------------------------------------- + +describe('TypeScript constructor-call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-constructor-calls'), + () => {}, + ); + }, 60000); + + it('resolves new User() as a CALLS edge to the User class', () => { + const calls = getRelationships(result, 'CALLS'); + const ctorCall = calls.find(c => c.target === 'User'); + expect(ctorCall).toBeDefined(); + expect(ctorCall!.source).toBe('processUser'); + expect(ctorCall!.targetLabel).toBe('Class'); + expect(ctorCall!.targetFilePath).toBe('src/user.ts'); + }); + + it('also resolves user.save() as a member call', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processUser'); + }); + + it('detects User class, save method, and processUser function', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + expect(getNodesByLabel(result, 'Function')).toContain('processUser'); + }); +}); + +// --------------------------------------------------------------------------- +// Receiver-constrained resolution: typed variables disambiguate same-named methods +// --------------------------------------------------------------------------- + +describe('TypeScript receiver-constrained resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-receiver-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User.save and repo.save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'src/user.ts'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'src/repo.ts'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('resolves constructor calls for both User and Repo', () => { + const calls = getRelationships(result, 'CALLS'); + const userCtor = calls.find(c => c.target === 'User' && c.targetLabel === 'Class'); + const repoCtor = calls.find(c => c.target === 'Repo' && c.targetLabel === 'Class'); + expect(userCtor).toBeDefined(); + expect(repoCtor).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Scoped receiver resolution: same variable name in different functions +// resolves to different types via scope-aware TypeEnv +// --------------------------------------------------------------------------- + +describe('TypeScript scoped receiver resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-scoped-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves entity.save() in handleUser to User.save and in handleRepo to Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + + const userSave = saveCalls.find(c => c.targetFilePath === 'src/user.ts'); + const repoSave = saveCalls.find(c => c.targetFilePath === 'src/repo.ts'); + + expect(userSave).toBeDefined(); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Named import disambiguation: two files export same name, import resolves +// --------------------------------------------------------------------------- + +describe('TypeScript named import disambiguation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-named-imports'), + () => {}, + ); + }, 60000); + + it('resolves processInput → formatData to src/format-upper.ts via named import', () => { + const calls = getRelationships(result, 'CALLS'); + const formatCall = calls.find(c => c.target === 'formatData'); + expect(formatCall).toBeDefined(); + expect(formatCall!.source).toBe('processInput'); + expect(formatCall!.targetFilePath).toBe('src/format-upper.ts'); + }); + + it('emits IMPORTS edge to format-upper.ts', () => { + const imports = getRelationships(result, 'IMPORTS'); + const appImport = imports.find(e => e.source === 'app.ts'); + expect(appImport).toBeDefined(); + expect(appImport!.targetFilePath).toBe('src/format-upper.ts'); + }); +}); + +// --------------------------------------------------------------------------- +// Alias import resolution: import { User as U } resolves U → User +// --------------------------------------------------------------------------- + +describe('TypeScript alias import resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-alias-imports'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with their methods', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + expect(getNodesByLabel(result, 'Method')).toContain('persist'); + }); + + it('resolves new U() to User class and new R() to Repo class via alias', () => { + const calls = getRelationships(result, 'CALLS'); + const userCtor = calls.find(c => c.target === 'User' && c.targetLabel === 'Class'); + const repoCtor = calls.find(c => c.target === 'Repo' && c.targetLabel === 'Class'); + + expect(userCtor).toBeDefined(); + expect(userCtor!.source).toBe('main'); + expect(userCtor!.targetFilePath).toBe('src/models.ts'); + + expect(repoCtor).toBeDefined(); + expect(repoCtor!.source).toBe('main'); + expect(repoCtor!.targetFilePath).toBe('src/models.ts'); + }); + + it('resolves u.save() and r.persist() as member calls', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + const persistCall = calls.find(c => c.target === 'persist'); + + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('main'); + }); + + it('emits IMPORTS edge from app.ts to models.ts', () => { + const imports = getRelationships(result, 'IMPORTS'); + const appImport = imports.find(e => e.sourceFilePath === 'src/app.ts'); + expect(appImport).toBeDefined(); + expect(appImport!.targetFilePath).toBe('src/models.ts'); + }); +}); + +// --------------------------------------------------------------------------- +// Re-export chain: export { X } from './base' barrel pattern +// --------------------------------------------------------------------------- + +describe('TypeScript re-export chain resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-reexport-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes in base.ts', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + }); + + it('resolves new User() through re-export chain to base.ts', () => { + const calls = getRelationships(result, 'CALLS'); + const userCtor = calls.find(c => c.target === 'User' && c.targetLabel === 'Class'); + expect(userCtor).toBeDefined(); + expect(userCtor!.source).toBe('main'); + expect(userCtor!.targetFilePath).toBe('src/base.ts'); + }); + + it('resolves user.save() through re-export chain to base.ts', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + expect(saveCall!.targetFilePath).toBe('src/base.ts'); + }); + + it('resolves new Repo() through re-export chain to base.ts', () => { + const calls = getRelationships(result, 'CALLS'); + const repoCtor = calls.find(c => c.target === 'Repo' && c.targetLabel === 'Class'); + expect(repoCtor).toBeDefined(); + expect(repoCtor!.source).toBe('main'); + expect(repoCtor!.targetFilePath).toBe('src/base.ts'); + }); + + it('resolves repo.persist() through re-export chain to base.ts', () => { + const calls = getRelationships(result, 'CALLS'); + const persistCall = calls.find(c => c.target === 'persist'); + expect(persistCall).toBeDefined(); + expect(persistCall!.source).toBe('main'); + expect(persistCall!.targetFilePath).toBe('src/base.ts'); + }); +}); + +// --------------------------------------------------------------------------- +// Re-export type chain: export type { X } from './base' barrel pattern +// --------------------------------------------------------------------------- + +describe('TypeScript export type re-export chain resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-reexport-type'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes in base.ts', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + }); + + it('resolves new User() through export type re-export chain to base.ts', () => { + const calls = getRelationships(result, 'CALLS'); + const userCtor = calls.find(c => c.target === 'User' && c.targetLabel === 'Class'); + expect(userCtor).toBeDefined(); + expect(userCtor!.source).toBe('main'); + expect(userCtor!.targetFilePath).toBe('src/base.ts'); + }); + + it('resolves user.save() through export type re-export chain to base.ts', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save'); + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('main'); + expect(saveCall!.targetFilePath).toBe('src/base.ts'); + }); +}); + +// --------------------------------------------------------------------------- +// Local shadow: same-file definition takes priority over imported name +// --------------------------------------------------------------------------- + +describe('TypeScript local definition shadows import', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-local-shadow'), + () => {}, + ); + }, 60000); + + it('resolves run → save to same-file definition, not the imported one', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'run'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/app.ts'); + }); + + it('does NOT resolve save to utils.ts', () => { + const calls = getRelationships(result, 'CALLS'); + const saveToUtils = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/utils.ts'); + expect(saveToUtils).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Variadic resolution: rest params don't get filtered by arity +// --------------------------------------------------------------------------- + +describe('TypeScript variadic call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-variadic-resolution'), + () => {}, + ); + }, 60000); + + it('resolves processInput → logEntry to src/logger.ts despite 3 args vs rest param', () => { + const calls = getRelationships(result, 'CALLS'); + const logCall = calls.find(c => c.target === 'logEntry'); + expect(logCall).toBeDefined(); + expect(logCall!.source).toBe('processInput'); + expect(logCall!.targetFilePath).toBe('src/logger.ts'); + }); +}); + +// --------------------------------------------------------------------------- +// Constructor-inferred type resolution: const user = new User(); user.save() +// Cross-file SymbolTable verification (no explicit type annotations) +// --------------------------------------------------------------------------- + +describe('TypeScript constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to src/user.ts via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/user.ts'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.save() to src/repo.ts via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/repo.ts'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// JavaScript constructor-inferred type resolution: const user = new User() +// --------------------------------------------------------------------------- + +describe('JavaScript constructor-inferred type resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'javascript-constructor-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to src/user.js via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/user.js'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves repo.save() to src/repo.js via constructor-inferred type', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/repo.js'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// this.save() resolves to enclosing class's own save method +// --------------------------------------------------------------------------- + +describe('TypeScript this resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-self-this-resolution'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves this.save() inside User.process to User.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => c.target === 'save' && c.source === 'process'); + expect(saveCall).toBeDefined(); + expect(saveCall!.targetFilePath).toBe('src/models/User.ts'); + }); +}); + +// --------------------------------------------------------------------------- +// Parent class resolution: EXTENDS + IMPLEMENTS edges +// --------------------------------------------------------------------------- + +describe('TypeScript parent resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel and User classes plus Serializable interface', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'User']); + expect(getNodesByLabel(result, 'Interface')).toEqual(['Serializable']); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('emits IMPLEMENTS edge: User → Serializable', () => { + const implements_ = getRelationships(result, 'IMPLEMENTS'); + expect(implements_.length).toBe(1); + expect(implements_[0].source).toBe('User'); + expect(implements_[0].target).toBe('Serializable'); + }); + + it('all heritage edges point to real graph nodes', () => { + for (const edge of [...getRelationships(result, 'EXTENDS'), ...getRelationships(result, 'IMPLEMENTS')]) { + const target = result.graph.getNode(edge.rel.targetId); + expect(target).toBeDefined(); + expect(target!.properties.name).toBe(edge.target); + } + }); +}); + +// --------------------------------------------------------------------------- +// super.save() resolves to parent class's save method +// --------------------------------------------------------------------------- + +describe('TypeScript super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-super-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(3); + }); + + it('emits EXTENDS edge: User → BaseModel', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('resolves super.save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const superSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'src/models/Base.ts'); + expect(superSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/models/Repo.ts'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// super.save() resolves to generic parent class's save method +// --------------------------------------------------------------------------- + +describe('TypeScript generic parent super resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-generic-parent-resolution'), + () => {}, + ); + }, 60000); + + it('detects BaseModel, User, and Repo classes, each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['BaseModel', 'Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(3); + }); + + it('emits EXTENDS edge: User → BaseModel (not BaseModel<string>)', () => { + const extends_ = getRelationships(result, 'EXTENDS'); + expect(extends_.length).toBe(1); + expect(extends_[0].source).toBe('User'); + expect(extends_[0].target).toBe('BaseModel'); + }); + + it('resolves super.save() inside User to BaseModel.save, not Repo.save', () => { + const calls = getRelationships(result, 'CALLS'); + const superSave = calls.find(c => c.source === 'save' && c.target === 'save' + && c.targetFilePath === 'src/models/Base.ts'); + expect(superSave).toBeDefined(); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/models/Repo.ts'); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Cast/non-null constructor inference: new X() as T, new X()! +// --------------------------------------------------------------------------- + +describe('TypeScript cast/non-null constructor inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-cast-constructor-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User.save via new User() as any', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/user.ts'); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() to Repo.save via new Repo()!', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/repo.ts'); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Double-cast constructor inference: new X() as unknown as T +// --------------------------------------------------------------------------- + +describe('TypeScript double-cast constructor inference', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-double-cast-inference'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User.save via new User() as unknown as any', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/user.ts'); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() to Repo.save via new Repo() as unknown as object', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/repo.ts'); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable/optional receiver unwrapping: user?.save() resolves through ?. +// --------------------------------------------------------------------------- + +describe('TypeScript nullable receiver resolution (optional chaining)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-nullable-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with their methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + expect(getNodesByLabel(result, 'Method')).toContain('greet'); + }); + + it('resolves user?.save() to User.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/user.ts'); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('processEntities'); + }); + + it('resolves user?.greet() to User.greet via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const greetCall = calls.find(c => c.target === 'greet' && c.targetFilePath === 'src/user.ts'); + expect(greetCall).toBeDefined(); + expect(greetCall!.source).toBe('processEntities'); + }); + + it('resolves repo?.save() to Repo.save via receiver typing', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => c.target === 'save' && c.targetFilePath === 'src/repo.ts'); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + }); + + it('emits constructor CALLS edges for both User and Repo', () => { + const calls = getRelationships(result, 'CALLS'); + const userCtor = calls.find(c => c.target === 'User' && c.targetLabel === 'Class'); + const repoCtor = calls.find(c => c.target === 'Repo' && c.targetLabel === 'Class'); + expect(userCtor).toBeDefined(); + expect(repoCtor).toBeDefined(); + }); + + it('emits exactly 2 save() CALLS edges (one per receiver type)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + // user?.save() → User.save + repo?.save() → Repo.save = 2 edges + // If nullable unwrapping fails, the resolver refuses ambiguous matches and emits 0 + expect(saveCalls.length).toBe(2); + }); +}); + +// --------------------------------------------------------------------------- +// Return type inference: const user = getUser('alice'); user.save() +// The TS/JS CONSTRUCTOR_BINDING_SCANNER captures variable_declarator nodes +// with plain call_expression values, enabling end-to-end return type inference. +// --------------------------------------------------------------------------- + +describe('TypeScript return type inference via explicit function return type', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-return-type-inference'), + () => {}, + ); + }, 60000); + + it('detects User class with save and getName methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('save'); + expect(methods).toContain('getName'); + }); + + it('detects getUser and fetchUserAsync functions', () => { + const functions = getNodesByLabel(result, 'Function'); + expect(functions).toContain('getUser'); + expect(functions).toContain('fetchUserAsync'); + }); + + it('resolves user.save() to User#save via return type of getUser(): User', () => { + // TS has explicit return types in the source, so extractMethodSignature captures + // the return type. The TS extractInitializer handles `const user = getUser()` + // via the variable_declarator path, enabling save() to resolve to User#save. + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('models') + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// JavaScript return type inference via JSDoc @returns annotation +// --------------------------------------------------------------------------- + +describe('JavaScript return type inference via JSDoc @returns annotation', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'js-jsdoc-return-type'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() to User#save via JSDoc @returns {User}', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('user.js'), + ); + expect(saveCall).toBeDefined(); + // Negative: must NOT resolve to Repo#save + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('repo.js'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves repo.save() to Repo#save via JSDoc @returns {Repo}', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath.includes('repo.js'), + ); + expect(saveCall).toBeDefined(); + // Negative: must NOT resolve to User#save + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath.includes('user.js'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves user.save() via JSDoc @param {User} in handleUser()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'handleUser' && c.targetFilePath.includes('user.js'), + ); + expect(saveCall).toBeDefined(); + // Negative: must NOT resolve to Repo#save + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'handleUser' && c.targetFilePath.includes('repo.js'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves repo.save() via JSDoc @param {Repo} in handleRepo()', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'handleRepo' && c.targetFilePath.includes('repo.js'), + ); + expect(saveCall).toBeDefined(); + // Negative: must NOT resolve to User#save + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'handleRepo' && c.targetFilePath.includes('user.js'), + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// JavaScript async return type inference via JSDoc @returns {Promise<User>} +// Verifies that wrapper generics (Promise) are unwrapped to the inner type. +// --------------------------------------------------------------------------- + +describe('JavaScript async return type inference via JSDoc @returns {Promise<User>}', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'js-jsdoc-async-return-type'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() to User#save via @returns {Promise<User>} unwrapping', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('user.js'), + ); + expect(saveCall).toBeDefined(); + // Negative: must NOT resolve to Repo#save + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('repo.js'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves repo.save() to Repo#save via @returns {Promise<Repo>} unwrapping', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath.includes('repo.js'), + ); + expect(saveCall).toBeDefined(); + // Negative: must NOT resolve to User#save + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'processRepo' && c.targetFilePath.includes('user.js'), + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// JavaScript qualified return type: @returns {Promise<models.User>} +// Verifies that dot-qualified names inside generics are not corrupted. +// --------------------------------------------------------------------------- + +describe('JavaScript qualified return type via JSDoc @returns {Promise<models.User>}', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'js-jsdoc-qualified-return-type'), + () => {}, + ); + }, 60000); + + it('resolves user.save() to User#save despite qualified return type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.source === 'processUser' && c.targetFilePath.includes('user.js'), + ); + expect(saveCall).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Assignment chain propagation (Tier 2, depth-1): +// `const alias = u` where `u: User` → alias.save() resolves to User#save +// --------------------------------------------------------------------------- + +describe('TypeScript assignment chain propagation (Tier 2)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-assignment-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves alias.save() to User#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCall = calls.find(c => + c.target === 'save' && c.targetFilePath.includes('user.ts'), + ); + // Positive: alias.save() must resolve to User#save + expect(saveCall).toBeDefined(); + expect(saveCall!.source).toBe('processEntities'); + // Negative: alias.save() must NOT resolve to Repo#save + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'processEntities' && c.targetFilePath.includes('repo.ts'), + ); + // rAlias.save() correctly goes to Repo — but we verify there is exactly one + // per-receiver resolution (user alias → User, repo alias → Repo) + expect(wrongCall).toBeDefined(); // rAlias.save() resolves to Repo + }); + + it('resolves rAlias.save() to Repo#save via assignment chain', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.targetFilePath.includes('repo.ts'), + ); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('processEntities'); + // Negative: rAlias.save() must NOT resolve to User#save (only) + const userSave = calls.find(c => + c.target === 'save' && c.targetFilePath.includes('user.ts'), + ); + expect(userSave).toBeDefined(); + // Both resolve separately — alias → User, rAlias → Repo + expect(userSave!.targetFilePath).not.toBe(repoSave!.targetFilePath); + }); +}); + +// --------------------------------------------------------------------------- +// Multi-hop forward-declared chain (a → b → c) — validates that single-pass +// in source order resolves chains deeper than depth-1. +// --------------------------------------------------------------------------- + +describe('TypeScript multi-hop assignment chain (a → b → c)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-multi-hop-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves c.save() to User#save through a → b → c chain', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'multiHopForward' && c.targetFilePath?.includes('user.ts'), + ); + expect(userSave).toBeDefined(); + }); + + it('c.save() in multiHopForward does NOT resolve to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'multiHopForward' && c.targetFilePath?.includes('repo.ts'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves c.save() to Repo#save through a → b → c chain (Repo variant)', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'multiHopRepo' && c.targetFilePath?.includes('repo.ts'), + ); + expect(repoSave).toBeDefined(); + }); + + it('c.save() in multiHopRepo does NOT resolve to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'multiHopRepo' && c.targetFilePath?.includes('user.ts'), + ); + expect(wrongCall).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Nullable type + assignment chain: stripNullable must resolve the nullable +// union (User | null → User) before the chain propagation can work. +// Exercises the refactored NULLABLE_KEYWORDS.has() code path. +// --------------------------------------------------------------------------- + +describe('TypeScript nullable + assignment chain combined', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-nullable-chain'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes each with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves alias.save() to User#save when source is User | null', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'nullableChainUser' && c.targetFilePath?.includes('user.ts'), + ); + expect(userSave).toBeDefined(); + }); + + it('alias.save() from User | null does NOT resolve to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongCall = calls.find(c => + c.target === 'save' && c.source === 'nullableChainUser' && c.targetFilePath?.includes('repo.ts'), + ); + expect(wrongCall).toBeUndefined(); + }); + + it('resolves alias.save() to Repo#save when source is Repo | undefined', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'nullableChainRepo' && c.targetFilePath?.includes('repo.ts'), + ); + expect(repoSave).toBeDefined(); + }); + + it('resolves alias.save() to User#save when source is User | null | undefined (triple)', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'tripleNullable' && c.targetFilePath?.includes('user.ts'), + ); + expect(userSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Chained method call resolution: svc.getUser().save() +// The receiver of save() is a call_expression (getUser()), not a simple identifier. +// Resolution must walk the chain: getUser() returns User, so save() → User#save. +// --------------------------------------------------------------------------- + +describe('TypeScript chained method call resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-chain-call'), + () => {}, + ); + }, 60000); + + it('detects User, Repo and UserService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects save methods on both User and Repo', () => { + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('detects getUser method on UserService', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('getUser'); + }); + + it('resolves svc.getUser().save() to User#save, NOT Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath.includes('User'), + ); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath.includes('Repo'), + ); + expect(userSave).toBeDefined(); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Overloaded receiver: two classes with the same method name (save) must not +// collide in the receiverKey map. The fix preserves @startIndex in the key so +// User.save@idx1 and Repo.save@idx2 remain distinct even when the enclosing +// scope funcName is the same. +// --------------------------------------------------------------------------- + +describe('TypeScript overloaded-receiver resolution (receiverKey collision fix)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-overloaded-receiver'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes, both with a save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + const saveMethods = getNodesByLabel(result, 'Method').filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.save() to User#save (models/User.ts), not Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.targetFilePath.includes('User'), + ); + expect(userSave).toBeDefined(); + expect(userSave!.source).toBe('run'); + // Negative: must not resolve to Repo#save + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'run' && c.targetFilePath.includes('Repo'), + ); + // If only one save target resolves to User (not Repo), we correctly exclude Repo + expect(userSave!.targetFilePath).toContain('User'); + }); + + it('resolves repo.save() to Repo#save (models/Repo.ts), not User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.targetFilePath.includes('Repo'), + ); + expect(repoSave).toBeDefined(); + expect(repoSave!.source).toBe('run'); + expect(repoSave!.targetFilePath).toContain('Repo'); + }); + + it('emits exactly 2 save() CALLS edges — one per class', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(c => c.target === 'save'); + expect(saveCalls.length).toBe(2); + const targets = saveCalls.map(c => c.targetFilePath).sort(); + expect(targets[0]).toContain('Repo'); + expect(targets[1]).toContain('User'); + }); + + it('resolves constructor calls for both User and Repo', () => { + const calls = getRelationships(result, 'CALLS'); + const userCtor = calls.find(c => c.target === 'User' && c.targetLabel === 'Class'); + const repoCtor = calls.find(c => c.target === 'Repo' && c.targetLabel === 'Class'); + expect(userCtor).toBeDefined(); + expect(repoCtor).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Typed parameter chain: svc.getUser().save() where svc is a parameter with +// a type annotation (not a constructor binding). Tests that the worker path +// consults typeEnv for chain base receivers (Phase 5 review Finding 1). +// --------------------------------------------------------------------------- + +describe('TypeScript typed-parameter chain call resolution (Phase 5 review fix)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-typed-param-chain'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, and UserService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects getUser and save methods', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('getUser'); + expect(methods).toContain('save'); + }); + + it('resolves svc.getUser().save() to User#save via parameter type annotation', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve svc.getUser().save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath.includes('Repo'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Static chain: UserService.findUser().save() where the chain base is a class +// name (not a variable). Tests that the serial path applies class-as-receiver +// to chain base resolution (Phase 5 review Finding 2). +// --------------------------------------------------------------------------- + +describe('TypeScript static class-name chain call resolution (Phase 5 review fix)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-static-chain'), + () => {}, + ); + }, 60000); + + it('detects User, Repo, and UserService classes', () => { + const classes = getNodesByLabel(result, 'Class'); + expect(classes).toContain('User'); + expect(classes).toContain('Repo'); + expect(classes).toContain('UserService'); + }); + + it('detects static findUser and instance save methods', () => { + const methods = getNodesByLabel(result, 'Method'); + expect(methods).toContain('findUser'); + expect(methods).toContain('save'); + }); + + it('resolves UserService.findUser().save() to User#save via class-name chain base', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve UserService.findUser().save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && + c.source === 'processUser' && + c.targetFilePath.includes('Repo'), + ); + expect(repoSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// TS readonly User[] for-loop: for (const user of users) with readonly User[] +// --------------------------------------------------------------------------- + +describe('TypeScript readonly array for-loop resolution (Tier 1c)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-readonly-foreach'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() in readonly array for-of to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('user'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in readonly array for-of to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('repo'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('repo'), + ); + expect(wrong).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// for (const [key, user] of entries) — destructured for-of resolution +// --------------------------------------------------------------------------- + +describe('TS destructured for-of Map resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-destructured-for-of'), + () => {}, + ); + }, 60000); + + it('detects User class with save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves user.save() in destructured for-of to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processEntries' && c.targetFilePath?.includes('user'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processEntries' && c.targetFilePath?.includes('repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// if (x instanceof User) { x.save() } — instanceof narrowing resolution +// --------------------------------------------------------------------------- + +describe('TS instanceof narrowing resolution', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-instanceof-narrowing'), + () => {}, + ); + }, 60000); + + it('detects User class with save method', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + }); + + it('resolves x.save() after instanceof to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath?.includes('user'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT resolve x.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'process' && c.targetFilePath?.includes('repo'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// this.users member access iterable: for (const user of this.users) +// --------------------------------------------------------------------------- + +describe('TypeScript member access iterable for-loop', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-member-access-for-loop'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('resolves user.save() via this.users to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('User'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('Repo'), + ); + expect(wrong).toBeUndefined(); + }); + + it('resolves repo.save() via this.repos to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('Repo'), + ); + expect(repoSave).toBeDefined(); + }); +}); + +// --------------------------------------------------------------------------- +// TypeScript class field foreach: for (const user of this.users) with class field User[] +// --------------------------------------------------------------------------- + +describe('TypeScript class field foreach resolution (Phase 6.1)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-class-field-foreach'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + expect(getNodesByLabel(result, 'Method')).toContain('save'); + }); + + it('resolves user.save() via class field User[] to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('user'), + ); + expect(userSave).toBeDefined(); + }); + + it('does NOT cross-resolve user.save() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('repo'), + ); + expect(wrong).toBeUndefined(); + }); + + it('resolves repo.save() via class field Map<string, Repo>.values() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('repo'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT cross-resolve repo.save() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const wrong = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('user'), + ); + expect(wrong).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// TypeScript for-of with call_expression iterable: for (const user of getUsers()) +// Phase 7.3: call_expression iterable resolution via ReturnTypeLookup +// --------------------------------------------------------------------------- + +describe('TypeScript for-of call_expression iterable resolution (Phase 7.3)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'typescript-for-of-call-expr'), + () => {}, + ); + }, 60000); + + it('detects User and Repo classes with competing save methods', () => { + expect(getNodesByLabel(result, 'Class')).toContain('User'); + expect(getNodesByLabel(result, 'Class')).toContain('Repo'); + }); + + it('resolves user.save() in for-of getUsers() to User#save', () => { + const calls = getRelationships(result, 'CALLS'); + const userSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('user.ts'), + ); + expect(userSave).toBeDefined(); + }); + + it('resolves repo.save() in for-of getRepos() to Repo#save', () => { + const calls = getRelationships(result, 'CALLS'); + const repoSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('repo.ts'), + ); + expect(repoSave).toBeDefined(); + }); + + it('does NOT resolve user.save() to Repo#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processUsers' && c.targetFilePath?.includes('repo.ts'), + ); + expect(wrongSave).toBeUndefined(); + }); + + it('does NOT resolve repo.save() to User#save (negative)', () => { + const calls = getRelationships(result, 'CALLS'); + const wrongSave = calls.find(c => + c.target === 'save' && c.source === 'processRepos' && c.targetFilePath?.includes('user.ts'), + ); + expect(wrongSave).toBeUndefined(); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field/property type resolution (1-level) +// --------------------------------------------------------------------------- + +describe('Field type resolution (TypeScript)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'field-types'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, Config, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'Config', 'User']); + }); + + it('detects Property nodes for typed fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('name'); + expect(properties).toContain('city'); + }); + + it('emits HAS_PROPERTY edges linking properties to classes', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(propEdges.length).toBe(4); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('Address → city'); + expect(edgeSet(propEdges)).toContain('Config → DEFAULT'); + }); + + it('resolves user.address.save() → Address#save via field type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save'); + const addressSave = saveCalls.find(e => e.targetFilePath.includes('models')); + expect(addressSave).toBeDefined(); + expect(addressSave!.source).toBe('processUser'); + }); + + it('emits ACCESSES read edge for user.address field access in chain', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const addressReads = accesses.filter(e => e.target === 'address' && e.rel.reason === 'read'); + expect(addressReads.length).toBe(1); + expect(addressReads[0].source).toBe('processUser'); + expect(addressReads[0].targetLabel).toBe('Property'); + }); + + it('emits ACCESSES read edge for Config.DEFAULT field access in chain', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const defaultReads = accesses.filter(e => e.target === 'DEFAULT' && e.rel.reason === 'read'); + expect(defaultReads.length).toBe(1); + expect(defaultReads[0].source).toBe('validateConfig'); + }); + + it('all ACCESSES edges have confidence 1.0 and reason read', () => { + const accesses = getRelationships(result, 'ACCESSES'); + for (const edge of accesses) { + expect(edge.rel.confidence).toBe(1.0); + expect(edge.rel.reason).toBe('read'); + } + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Field type disambiguation — both User and Address have save() +// --------------------------------------------------------------------------- + +describe('Field type disambiguation (TypeScript)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-field-type-disambig'), + () => {}, + ); + }, 60000); + + it('detects both User#save and Address#save', () => { + const methods = getNodesByLabel(result, 'Method'); + const saveMethods = methods.filter(m => m === 'save'); + expect(saveMethods.length).toBe(2); + }); + + it('resolves user.address.save() → Address#save (not User#save)', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter( + e => e.target === 'save' && e.source === 'processUser', + ); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('address'); + expect(saveCalls[0].targetFilePath).not.toContain('user'); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8: Parameter properties and #private fields +// --------------------------------------------------------------------------- + +describe('Field type resolution (TS parameter properties)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-param-property-fields'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'User']); + }); + + it('captures constructor parameter properties as Property nodes', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('name'); + expect(properties).toContain('address'); + }); + + it('captures #private fields as Property nodes', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('#secret'); + }); + + it('emits HAS_PROPERTY edges for parameter properties', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → name'); + expect(edgeSet(propEdges)).toContain('User → address'); + }); + + it('resolves user.address.save() via parameter property type', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'processUser'); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('models'); + }); +}); + +// --------------------------------------------------------------------------- +// Phase 8A: Deep field chain resolution (3-level: user.address.city.getName()) +// --------------------------------------------------------------------------- + +describe('Deep field chain resolution (TypeScript)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-deep-field-chain'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, City, User', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'City', 'User']); + }); + + it('detects Property nodes for all typed fields', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('address'); + expect(properties).toContain('city'); + expect(properties).toContain('zipCode'); + }); + + it('emits HAS_PROPERTY edges for nested type chain', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toContain('User → address'); + expect(edgeSet(propEdges)).toContain('Address → city'); + expect(edgeSet(propEdges)).toContain('City → zipCode'); + }); + + it('resolves 2-level chain: user.address.save() → Address#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'processUser'); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('models'); + }); + + it('resolves 3-level chain: user.address.city.getName() → City#getName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'getName' && e.source === 'processUser'); + expect(getNameCalls.length).toBe(1); + expect(getNameCalls[0].targetFilePath).toContain('models'); + }); +}); + +// --------------------------------------------------------------------------- +// Mixed chain resolution (field ↔ call interleaved) +// --------------------------------------------------------------------------- + +describe('Mixed field+call chain resolution (TypeScript)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-mixed-chain'), + () => {}, + ); + }, 60000); + + it('detects classes: Address, City, User, UserService', () => { + expect(getNodesByLabel(result, 'Class')).toEqual(['Address', 'City', 'User', 'UserService']); + }); + + it('detects Property node for Address.city field', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('city'); + expect(properties).toContain('address'); + }); + + it('resolves call→field chain: svc.getUser().address.save() → Address#save', () => { + const calls = getRelationships(result, 'CALLS'); + const saveCalls = calls.filter(e => e.target === 'save' && e.source === 'processWithService'); + expect(saveCalls.length).toBe(1); + expect(saveCalls[0].targetFilePath).toContain('models'); + }); + + it('resolves field→call chain: user.getAddress().city.getName() → City#getName', () => { + const calls = getRelationships(result, 'CALLS'); + const getNameCalls = calls.filter(e => e.target === 'getName' && e.source === 'processWithUser'); + expect(getNameCalls.length).toBe(1); + expect(getNameCalls[0].targetFilePath).toContain('models'); + }); +}); + +// --------------------------------------------------------------------------- +// ACCESSES write edges from assignment expressions +// --------------------------------------------------------------------------- + +describe('Write access tracking (TypeScript)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'ts-write-access'), + () => {}, + ); + }, 60000); + + it('emits ACCESSES write edges for field assignments', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + expect(writes.length).toBe(2); + const nameWrite = writes.find(e => e.target === 'name'); + const addressWrite = writes.find(e => e.target === 'address'); + expect(nameWrite).toBeDefined(); + expect(nameWrite!.source).toBe('updateUser'); + expect(addressWrite).toBeDefined(); + expect(addressWrite!.source).toBe('updateUser'); + }); + + it('write ACCESSES edges have confidence 1.0', () => { + const accesses = getRelationships(result, 'ACCESSES'); + const writes = accesses.filter(e => e.rel.reason === 'write'); + for (const edge of writes) { + expect(edge.rel.confidence).toBe(1.0); + } + }); +}); diff --git a/gitnexus/test/integration/search-core.test.ts b/gitnexus/test/integration/search-core.test.ts new file mode 100644 index 0000000000..5f8d5ccc9e --- /dev/null +++ b/gitnexus/test/integration/search-core.test.ts @@ -0,0 +1,121 @@ +/** + * P0 Integration Tests: BM25/FTS Search against real LadybugDB + * + * Tests: searchFTSFromLbug via core adapter (no repoId) path against + * indexed test data. Verifies ranked result ordering, score merging, + * and empty-match behavior. + * + * Uses withTestLbugDB wrapper for full lifecycle management. + */ +import { describe, it, expect } from 'vitest'; +import { withTestLbugDB } from '../helpers/test-indexed-db.js'; +import { searchFTSFromLbug } from '../../src/core/search/bm25-index.js'; +import { SEARCH_SEED_DATA, SEARCH_FTS_INDEXES } from '../fixtures/search-seed.js'; + +// ─── Core adapter path (no repoId) ────────────────────────────────── + +withTestLbugDB('search-core', (_handle) => { + describe('searchFTSFromLbug — core adapter (no repoId)', () => { + it('returns ranked results for a matching query', async () => { + const results = await searchFTSFromLbug('user authentication', 10); + + expect(results.length).toBeGreaterThan(0); + + for (const r of results) { + expect(r).toHaveProperty('filePath'); + expect(r).toHaveProperty('score'); + expect(r).toHaveProperty('rank'); + expect(typeof r.filePath).toBe('string'); + expect(typeof r.score).toBe('number'); + expect(typeof r.rank).toBe('number'); + expect(r.score).toBeGreaterThan(0); + } + + // Ranks should be sequential starting from 1 + results.forEach((r, i) => { + expect(r.rank).toBe(i + 1); + }); + }); + + it('results are ordered by descending score', async () => { + const results = await searchFTSFromLbug('user authentication', 10); + + for (let i = 1; i < results.length; i++) { + expect(results[i - 1].score).toBeGreaterThanOrEqual(results[i].score); + } + }); + + it('auth-related files rank higher than unrelated files', async () => { + const results = await searchFTSFromLbug('user authentication', 10); + const filePaths = results.map((r) => r.filePath); + + expect(filePaths).toContain('src/auth.ts'); + + const authIdx = filePaths.indexOf('src/auth.ts'); + const utilsIdx = filePaths.indexOf('src/utils.ts'); + if (utilsIdx !== -1) { + expect(authIdx).toBeLessThan(utilsIdx); + } + }); + + it('merges scores from multiple node types for the same filePath', async () => { + const results = await searchFTSFromLbug('user authentication', 20); + + const authResult = results.find((r) => r.filePath === 'src/auth.ts'); + expect(authResult).toBeDefined(); + + const routerResult = results.find((r) => r.filePath === 'src/router.ts'); + if (routerResult) { + expect(authResult!.score).toBeGreaterThan(routerResult.score); + } + }); + + it('respects limit parameter', async () => { + const results = await searchFTSFromLbug('user authentication', 2); + expect(results.length).toBeLessThanOrEqual(2); + }); + + it('returns empty array for a non-matching query', async () => { + const results = await searchFTSFromLbug('xyzzyplughtwisty', 10); + expect(results).toEqual([]); + }); + }); + + // ─── Unhappy paths ────────────────────────────────────────────────── + + describe('unhappy paths', () => { + it('returns empty array for empty query string', async () => { + const results = await searchFTSFromLbug('', 10); + expect(results).toEqual([]); + }); + + it('returns empty array for whitespace-only query', async () => { + const results = await searchFTSFromLbug(' ', 10); + expect(results).toEqual([]); + }); + + it('handles special characters in query gracefully', async () => { + const results = await searchFTSFromLbug('user* OR auth+', 10); + expect(Array.isArray(results)).toBe(true); + }); + + it('handles limit of 0', async () => { + const results = await searchFTSFromLbug('user authentication', 0); + expect(results).toEqual([]); + }); + + it('handles negative limit gracefully', async () => { + const results = await searchFTSFromLbug('user authentication', -1); + expect(Array.isArray(results)).toBe(true); + }); + + it('handles very large limit', async () => { + const results = await searchFTSFromLbug('user authentication', 100000); + expect(results.length).toBeLessThanOrEqual(100000); + expect(results.length).toBeGreaterThan(0); + }); + }); +}, { + seed: SEARCH_SEED_DATA, + ftsIndexes: SEARCH_FTS_INDEXES, +}); diff --git a/gitnexus/test/integration/search-pool.test.ts b/gitnexus/test/integration/search-pool.test.ts new file mode 100644 index 0000000000..b665197775 --- /dev/null +++ b/gitnexus/test/integration/search-pool.test.ts @@ -0,0 +1,81 @@ +/** + * P0 Integration Tests: BM25/FTS Search against real LadybugDB + * + * Tests: searchFTSFromLbug via MCP pool adapter (with repoId) path + * against indexed test data. Verifies ranked result ordering and + * empty-match behavior through the pool adapter. + * + * Uses withTestLbugDB wrapper for full lifecycle management. + */ +import { describe, it, expect } from 'vitest'; +import { withTestLbugDB } from '../helpers/test-indexed-db.js'; +import { searchFTSFromLbug } from '../../src/core/search/bm25-index.js'; +import { SEARCH_SEED_DATA, SEARCH_FTS_INDEXES } from '../fixtures/search-seed.js'; + +// ─── MCP pool adapter path (with repoId) ──────────────────────────── + +withTestLbugDB('search-pool', (handle) => { + describe('searchFTSFromLbug — MCP pool adapter (with repoId)', () => { + it('returns ranked results via pool adapter', async () => { + const results = await searchFTSFromLbug('user authentication', 10, handle.repoId); + + expect(results.length).toBeGreaterThan(0); + + for (const r of results) { + expect(r).toHaveProperty('filePath'); + expect(r).toHaveProperty('score'); + expect(r).toHaveProperty('rank'); + expect(r.score).toBeGreaterThan(0); + } + + const filePaths = results.map((r) => r.filePath); + expect(filePaths).toContain('src/auth.ts'); + }); + + it('results are ordered by descending score via pool adapter', async () => { + const results = await searchFTSFromLbug('user authentication', 10, handle.repoId); + + for (let i = 1; i < results.length; i++) { + expect(results[i - 1].score).toBeGreaterThanOrEqual(results[i].score); + } + }); + + it('returns empty array for non-matching query via pool adapter', async () => { + const results = await searchFTSFromLbug('xyzzyplughtwisty', 10, handle.repoId); + expect(results).toEqual([]); + }); + + it('respects limit parameter via pool adapter', async () => { + const results = await searchFTSFromLbug('user authentication', 1, handle.repoId); + expect(results.length).toBeLessThanOrEqual(1); + }); + }); + + // ─── Unhappy paths ────────────────────────────────────────────────── + + describe('unhappy paths', () => { + it('returns empty array for empty query via pool', async () => { + const results = await searchFTSFromLbug('', 10, handle.repoId); + expect(results).toEqual([]); + }); + + it('returns empty array for whitespace-only query via pool', async () => { + const results = await searchFTSFromLbug(' ', 10, handle.repoId); + expect(results).toEqual([]); + }); + + it('handles special characters in query via pool', async () => { + const results = await searchFTSFromLbug('user* OR auth+', 10, handle.repoId); + expect(Array.isArray(results)).toBe(true); + }); + + it('handles limit of 0 via pool', async () => { + const results = await searchFTSFromLbug('user authentication', 0, handle.repoId); + expect(results).toEqual([]); + }); + }); +}, { + seed: SEARCH_SEED_DATA, + ftsIndexes: SEARCH_FTS_INDEXES, + poolAdapter: true, +}); diff --git a/gitnexus/test/integration/setup-skills.test.ts b/gitnexus/test/integration/setup-skills.test.ts new file mode 100644 index 0000000000..f6f35f76f2 --- /dev/null +++ b/gitnexus/test/integration/setup-skills.test.ts @@ -0,0 +1,88 @@ +import { describe, it, expect, beforeAll, afterAll } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import os from 'os'; +import { fileURLToPath } from 'url'; +import { setupCommand } from '../../src/cli/setup.js'; + +describe('setupCommand skills integration', () => { + let tempHome: string; + const originalHome = process.env.HOME; + const originalUserProfile = process.env.USERPROFILE; + const testId = `${Date.now()}-${process.pid}`; + const flatSkillName = `test-flat-skill-${testId}`; + const dirSkillName = `test-dir-skill-${testId}`; + const testDir = path.dirname(fileURLToPath(import.meta.url)); + const packageSkillsRoot = path.resolve(testDir, '..', '..', 'skills'); + + beforeAll(async () => { + tempHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-setup-home-')); + process.env.HOME = tempHome; + process.env.USERPROFILE = tempHome; // os.homedir() checks USERPROFILE on Windows + await fs.mkdir(path.join(tempHome, '.cursor'), { recursive: true }); + + // Create temporary source skills to verify both supported source layouts: + // - flat file: skills/{name}.md + // - directory: skills/{name}/SKILL.md (+ nested files copied recursively) + await fs.writeFile( + path.join(packageSkillsRoot, `${flatSkillName}.md`), + `---\nname: ${flatSkillName}\ndescription: temp flat skill\n---\n\n# Flat Test Skill`, + 'utf-8', + ); + await fs.mkdir(path.join(packageSkillsRoot, dirSkillName, 'references'), { recursive: true }); + await fs.writeFile( + path.join(packageSkillsRoot, dirSkillName, 'SKILL.md'), + `---\nname: ${dirSkillName}\ndescription: temp directory skill\n---\n\n# Directory Test Skill`, + 'utf-8', + ); + await fs.writeFile( + path.join(packageSkillsRoot, dirSkillName, 'references', 'note.md'), + '# Directory Nested File', + 'utf-8', + ); + }); + + afterAll(async () => { + await fs.rm(path.join(packageSkillsRoot, `${flatSkillName}.md`), { force: true }); + await fs.rm(path.join(packageSkillsRoot, dirSkillName), { recursive: true, force: true }); + process.env.HOME = originalHome; + process.env.USERPROFILE = originalUserProfile; + await fs.rm(tempHome, { recursive: true, force: true }); + }); + + it('installs packaged, flat-file, and directory skills into cursor skills directory', async () => { + await setupCommand(); + + const cursorSkillsRoot = path.join(tempHome, '.cursor', 'skills'); + const entries = await fs.readdir(cursorSkillsRoot, { withFileTypes: true }); + const skillDirs = entries.filter(e => e.isDirectory()).map(e => e.name); + + expect(skillDirs.length).toBeGreaterThan(0); + expect(skillDirs).toContain('gitnexus-cli'); + + const skillContent = await fs.readFile( + path.join(cursorSkillsRoot, 'gitnexus-cli', 'SKILL.md'), + 'utf-8', + ); + expect(skillContent).toContain('GitNexus CLI Commands'); + + // Flat file source should be installed as {name}/SKILL.md. + const flatInstalled = await fs.readFile( + path.join(cursorSkillsRoot, flatSkillName, 'SKILL.md'), + 'utf-8', + ); + expect(flatInstalled).toContain('# Flat Test Skill'); + + // Directory source should be copied recursively with nested files preserved. + const dirInstalled = await fs.readFile( + path.join(cursorSkillsRoot, dirSkillName, 'SKILL.md'), + 'utf-8', + ); + expect(dirInstalled).toContain('# Directory Test Skill'); + const nestedInstalled = await fs.readFile( + path.join(cursorSkillsRoot, dirSkillName, 'references', 'note.md'), + 'utf-8', + ); + expect(nestedInstalled).toContain('Directory Nested File'); + }); +}); diff --git a/gitnexus/test/integration/skills-e2e.test.ts b/gitnexus/test/integration/skills-e2e.test.ts new file mode 100644 index 0000000000..31f836179a --- /dev/null +++ b/gitnexus/test/integration/skills-e2e.test.ts @@ -0,0 +1,2420 @@ +/** + * E2E Integration Tests: --skills Flag + * + * Tests `gitnexus analyze --skills` across 11 supported languages plus + * mixed-language and idempotency scenarios. Each language fixture creates + * a self-contained git repo with 2 clusters of files containing cross-file + * function calls, then runs the full CLI pipeline and verifies SKILL.md + * generation and context file updates. + * + * Uses process.execPath (never 'node' string), no shell: true. + * Accepts status === null (timeout) as valid on slow CI runners. + */ +import { describe, it, expect, beforeAll, afterAll } from 'vitest'; +import { spawnSync } from 'child_process'; +import path from 'path'; +import fs from 'fs'; +import os from 'os'; +import { fileURLToPath, pathToFileURL } from 'url'; +import { createRequire } from 'module'; + +const testDir = path.dirname(fileURLToPath(import.meta.url)); +const repoRoot = path.resolve(testDir, '../..'); +const cliEntry = path.join(repoRoot, 'src/cli/index.ts'); + +// Absolute file:// URL to tsx loader — needed when spawning CLI with cwd +// outside the project tree (bare 'tsx' specifier won't resolve there). +const _require = createRequire(import.meta.url); +const tsxPkgDir = path.dirname(_require.resolve('tsx/package.json')); +const tsxImportUrl = pathToFileURL(path.join(tsxPkgDir, 'dist', 'loader.mjs')).href; + +// ============================================================================ +// FILE-LOCAL HELPERS +// ============================================================================ + +/** + * Spawn the CLI with `analyze --skills` in the given cwd. + * Uses the absolute tsx loader URL so it works outside the project tree. + */ +function runSkillsCli(cwd: string, timeoutMs = 45000) { + return spawnSync(process.execPath, ['--import', tsxImportUrl, cliEntry, 'analyze', '--skills'], { + cwd, + encoding: 'utf8', + timeout: timeoutMs, + stdio: ['pipe', 'pipe', 'pipe'], + env: { + ...process.env, + NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=8192`.trim(), + }, + }); +} + +/** + * Create a fixture repo: write files, git init, git add, git commit. + * Returns the tmp directory path. + */ +function createFixtureRepo( + prefix: string, + files: Record<string, string>, +): string { + const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `skills-e2e-${prefix}-`)); + for (const [relPath, content] of Object.entries(files)) { + const fullPath = path.join(tmpDir, relPath); + fs.mkdirSync(path.dirname(fullPath), { recursive: true }); + fs.writeFileSync(fullPath, content, 'utf-8'); + } + spawnSync('git', ['init'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['add', '-A'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['commit', '-m', 'initial commit'], { + cwd: tmpDir, + stdio: 'pipe', + env: { + ...process.env, + GIT_AUTHOR_NAME: 'test', + GIT_AUTHOR_EMAIL: 'test@test', + GIT_COMMITTER_NAME: 'test', + GIT_COMMITTER_EMAIL: 'test@test', + }, + }); + return tmpDir; +} + +/** + * Assert standard skill file properties: + * 1. CLI exits 0 + * 2. .gitnexus/ exists + * 3. >= minSkills SKILL.md files under .claude/skills/generated/ + * 4. YAML frontmatter valid + * 5. ## Key Files section present + * 6. ## How to Explore section present + * 7. Content > 200 chars + * + * Returns false if skill generation was skipped (native parser crash + * or Leiden non-determinism producing 0 communities). Callers can + * use this to skip dependent assertions. + */ +function assertSkillFiles( + result: ReturnType<typeof runSkillsCli>, + tmpDir: string, + minSkills = 1, +): boolean { + /* CI timeout tolerance */ + if (result.status === null) return false; + + expect(result.status, [ + `analyze --skills exited with code ${result.status}`, + `stdout: ${result.stdout?.slice(0, 500)}`, + `stderr: ${result.stderr?.slice(0, 500)}`, + ].join('\n')).toBe(0); + + expect(fs.existsSync(path.join(tmpDir, '.gitnexus'))).toBe(true); + + const generatedDir = path.join(tmpDir, '.claude', 'skills', 'generated'); + if (!fs.existsSync(generatedDir)) { + // Native parser may have crashed in worker or Leiden produced 0 communities. + // The pipeline still succeeds (exit 0) but no skills are generated. + // Skip skill assertions gracefully — this is platform-dependent. + return false; + } + + const skillDirs = fs.readdirSync(generatedDir).filter(d => + fs.statSync(path.join(generatedDir, d)).isDirectory(), + ); + const skillFiles: string[] = []; + for (const dir of skillDirs) { + const skillPath = path.join(generatedDir, dir, 'SKILL.md'); + if (fs.existsSync(skillPath)) { + skillFiles.push(skillPath); + } + } + + expect(skillFiles.length).toBeGreaterThanOrEqual(minSkills); + + for (const skillPath of skillFiles) { + const content = fs.readFileSync(skillPath, 'utf-8'); + expect(content.startsWith('---')).toBe(true); + expect(content).toContain('name:'); + expect(content).toContain('description:'); + expect(content).toContain('## Key Files'); + expect(content).toContain('## How to Explore'); + expect(content.length).toBeGreaterThan(200); + } + + return true; +} + +/** + * Assert CLAUDE.md and AGENTS.md contain generated skill references. + * Automatically detects whether skills were generated by checking for + * the generated/ directory. + */ +function assertContextFiles( + result: ReturnType<typeof runSkillsCli>, + tmpDir: string, +) { + if (result.status === null) return; + + const generatedDir = path.join(tmpDir, '.claude', 'skills', 'generated'); + const skillsGenerated = fs.existsSync(generatedDir); + + const claudePath = path.join(tmpDir, 'CLAUDE.md'); + expect(fs.existsSync(claudePath)).toBe(true); + if (skillsGenerated) { + const claudeContent = fs.readFileSync(claudePath, 'utf-8'); + expect(claudeContent).toContain('.claude/skills/generated/'); + } + + const agentsPath = path.join(tmpDir, 'AGENTS.md'); + expect(fs.existsSync(agentsPath)).toBe(true); + if (skillsGenerated) { + const agentsContent = fs.readFileSync(agentsPath, 'utf-8'); + expect(agentsContent).toContain('.claude/skills/generated/'); + } +} + +// ============================================================================ +// DESCRIBE 1: TypeScript +// ============================================================================ + +describe('TypeScript', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('typescript', { + 'src/api/router.ts': ` +import { validateRequest } from '../utils/validator'; +import { logRequest } from '../utils/logger'; + +export function createRouter() { + validateRequest('route'); + logRequest('router init'); + return { routes: [] }; +} + +export function registerRoute(path: string) { + validateRequest(path); + logRequest('register ' + path); + return true; +} +`, + 'src/api/controller.ts': ` +import { runQuery } from '../data/query'; +import { formatResponse } from '../data/format'; + +export function handleGet(id: string) { + const data = runQuery('SELECT * FROM items WHERE id = ' + id); + return formatResponse(data); +} + +export function handlePost(body: any) { + const result = runQuery('INSERT INTO items VALUES ' + JSON.stringify(body)); + return formatResponse(result); +} +`, + 'src/api/middleware.ts': ` +import { validateToken } from '../utils/validator'; +import { logRequest } from '../utils/logger'; + +export function authMiddleware(req: any) { + validateToken(req.headers.auth); + logRequest('auth check'); + return true; +} + +export function corsMiddleware(req: any) { + logRequest('cors check'); + return { allowed: true }; +} +`, + 'src/data/query.ts': ` +import { formatResult } from './format'; +import { getCached } from './cache'; + +export function runQuery(sql: string) { + const cached = getCached(sql); + if (cached) return cached; + return formatResult({ sql, rows: [] }); +} + +export function buildQuery(table: string, conditions: any) { + return 'SELECT * FROM ' + table; +} +`, + 'src/data/format.ts': ` +export function formatResult(data: any) { + return { ...data, formatted: true }; +} + +export function formatResponse(data: any) { + return { status: 200, body: formatResult(data) }; +} + +export function serializeResult(data: any) { + return JSON.stringify(data); +} +`, + 'src/data/cache.ts': ` +import { runQuery } from './query'; + +const cache = new Map<string, any>(); + +export function getCached(key: string) { + return cache.get(key) || null; +} + +export function warmCache(keys: string[]) { + for (const key of keys) { + cache.set(key, runQuery(key)); + } +} +`, + 'src/utils/logger.ts': ` +export function logRequest(msg: string) { + console.log('[REQ]', msg); +} + +export function logError(msg: string) { + console.error('[ERR]', msg); +} + +export function createLogEntry(level: string, msg: string) { + return { level, msg, ts: Date.now() }; +} +`, + 'src/utils/validator.ts': ` +export function validateRequest(input: string) { + if (!input || input.length === 0) throw new Error('Invalid'); + return true; +} + +export function validateToken(token: string) { + if (!token || token.length < 10) throw new Error('Invalid token'); + return true; +} + +export function sanitize(input: string) { + return input.replace(/[<>]/g, ''); +} +`, + 'src/utils/config.ts': ` +export function getConfig(key: string) { + return process.env[key] || ''; +} + +export function loadEnv() { + return { ...process.env }; +} + +export function parseArgs(args: string[]) { + return args.reduce((acc: any, arg) => { + const [k, v] = arg.split('='); + acc[k] = v; + return acc; + }, {}); +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * TypeScript repo with 3 clusters of cross-calling functions. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 2: JavaScript +// ============================================================================ + +describe('JavaScript', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('javascript', { + 'src/handlers/userHandler.js': ` +const { findById } = require('../services/userService'); +const { validateInput } = require('../helpers/validator'); + +function getUser(id) { + validateInput(id); + return findById(id); +} + +function createUser(data) { + validateInput(data.name); + return { id: Date.now(), ...data }; +} + +module.exports = { getUser, createUser }; +`, + 'src/handlers/authHandler.js': ` +const { hashPassword, createToken } = require('../services/authService'); + +function login(username, password) { + const hashed = hashPassword(password); + return createToken(username); +} + +function logout(token) { + return { success: true }; +} + +module.exports = { login, logout }; +`, + 'src/handlers/errorHandler.js': ` +const { logError } = require('../helpers/logger'); + +function handleError(err) { + logError(err.message); + return { error: err.message }; +} + +function formatError(err) { + logError('format: ' + err.message); + return { code: err.code || 500, message: err.message }; +} + +module.exports = { handleError, formatError }; +`, + 'src/services/userService.js': ` +const { formatUser } = require('./formatService'); + +function findById(id) { + const user = { id, name: 'Test' }; + return formatUser(user); +} + +function saveUser(user) { + return { ...user, saved: true }; +} + +module.exports = { findById, saveUser }; +`, + 'src/services/authService.js': ` +function hashPassword(password) { + return 'hashed_' + password; +} + +function createToken(username) { + return 'token_' + username + '_' + Date.now(); +} + +function verifyToken(token) { + return token.startsWith('token_'); +} + +module.exports = { hashPassword, createToken, verifyToken }; +`, + 'src/services/formatService.js': ` +function formatUser(user) { + return { ...user, displayName: user.name.toUpperCase() }; +} + +function formatDate(date) { + return new Date(date).toISOString(); +} + +function formatError(err) { + return { error: true, message: String(err) }; +} + +module.exports = { formatUser, formatDate, formatError }; +`, + 'src/helpers/validator.js': ` +function validateInput(input) { + if (!input) throw new Error('Required'); + return true; +} + +function validateEmail(email) { + return /^[^@]+@[^@]+$/.test(email); +} + +function sanitize(str) { + return String(str).replace(/[<>]/g, ''); +} + +module.exports = { validateInput, validateEmail, sanitize }; +`, + 'src/helpers/logger.js': ` +function logError(msg) { + console.error('[ERROR]', msg); +} + +function logInfo(msg) { + console.log('[INFO]', msg); +} + +function createEntry(level, msg) { + return { level, msg, ts: Date.now() }; +} + +module.exports = { logError, logInfo, createEntry }; +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * JavaScript repo with handler/service/helper clusters. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 3: Python +// ============================================================================ + +describe('Python', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('python', { + 'src/auth/__init__.py': '', + 'src/auth/login.py': ` +from src.auth.hash import hash_password +from src.auth.session import create_session + +def login(username, password): + hashed = hash_password(password) + session = create_session(username) + return session + +def validate_credentials(username, password): + if not username or not password: + raise ValueError("Invalid credentials") + return True +`, + 'src/auth/hash.py': ` +def hash_password(password): + return "hashed_" + password + +def compare_hash(plain, hashed): + return hash_password(plain) == hashed + +def generate_salt(): + return "salt_" + str(id(object())) +`, + 'src/auth/session.py': ` +from src.auth.login import login + +def create_session(username): + return {"user": username, "token": "sess_" + username} + +def validate_session(session): + return session and "token" in session + +def refresh_session(session): + return create_session(session["user"]) +`, + 'src/database/__init__.py': '', + 'src/database/query.py': ` +from src.database.format import format_result +from src.database.cache import get_cached + +def run_query(sql): + cached = get_cached(sql) + if cached: + return cached + return format_result({"sql": sql, "rows": []}) + +def build_query(table, conditions): + return f"SELECT * FROM {table}" +`, + 'src/database/format.py': ` +def format_result(data): + return {**data, "formatted": True} + +def serialize_result(data): + import json + return json.dumps(data) + +def format_error(err): + return {"error": str(err)} +`, + 'src/database/cache.py': ` +from src.database.query import run_query + +_cache = {} + +def get_cached(key): + return _cache.get(key) + +def warm_cache(keys): + for key in keys: + _cache[key] = run_query(key) +`, + 'src/utils/__init__.py': '', + 'src/utils/logger.py': ` +def log_info(msg): + print(f"[INFO] {msg}") + +def log_error(msg): + print(f"[ERROR] {msg}") + +def create_entry(level, msg): + return {"level": level, "msg": msg} +`, + 'src/utils/validator.py': ` +def validate_input(data): + if not data: + raise ValueError("Input required") + return True + +def sanitize(text): + return text.replace("<", "").replace(">", "") + +def check_length(text, max_len=255): + return len(text) <= max_len +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * Python repo with auth/database/utils clusters. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 4: Go +// ============================================================================ + +describe('Go', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('go', { + 'go.mod': `module example.com/testapp + +go 1.21 +`, + 'cmd/main.go': `package main + +import ( + "example.com/testapp/pkg/handler" +) + +func main() { + handler.HandleGet("1") + handler.HandlePost(map[string]string{"name": "test"}) +} +`, + 'pkg/handler/get.go': `package handler + +import ( + "example.com/testapp/pkg/service" +) + +func HandleGet(id string) map[string]interface{} { + user := service.FindUser(id) + return service.FormatResponse(user) +} +`, + 'pkg/handler/post.go': `package handler + +import ( + "example.com/testapp/pkg/service" +) + +func HandlePost(data map[string]string) map[string]interface{} { + service.ValidateInput(data) + return service.CreateUser(data) +} +`, + 'pkg/service/user.go': `package service + +import ( + "example.com/testapp/pkg/repository" +) + +func FindUser(id string) map[string]interface{} { + return repository.GetByID(id) +} + +func CreateUser(data map[string]string) map[string]interface{} { + repository.Save(data) + return map[string]interface{}{"created": true} +} +`, + 'pkg/service/format.go': `package service + +func FormatResponse(data map[string]interface{}) map[string]interface{} { + data["formatted"] = true + return data +} + +func ValidateInput(data map[string]string) bool { + return len(data) > 0 +} + +func Sanitize(input string) string { + return input +} +`, + 'pkg/repository/user_repo.go': `package repository + +func GetByID(id string) map[string]interface{} { + return map[string]interface{}{"id": id, "name": "Test"} +} + +func Save(data map[string]string) bool { + return true +} + +func Delete(id string) bool { + return true +} +`, + 'pkg/models/user.go': `package models + +type User struct { + ID string + Name string +} + +func NewUser(id, name string) *User { + return &User{ID: id, Name: name} +} + +func (u *User) Validate() bool { + return u.ID != "" && u.Name != "" +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * Go repo with handler/service/repository clusters. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 5: Java +// ============================================================================ + +describe('Java', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('java', { + 'src/service/UserService.java': `package service; + +import repository.UserRepository; +import service.Validator; + +public class UserService { + private UserRepository repository = new UserRepository(); + private Validator validator = new Validator(); + + public Object findUser(String id) { + validator.validate(id); + return repository.getById(id); + } + + public Object createUser(String name) { + validator.validate(name); + return repository.save(name); + } +} +`, + 'src/service/AuthService.java': `package service; + +public class AuthService { + private UserService userService = new UserService(); + + public Object authenticate(String username, String password) { + Object user = userService.findUser(username); + return hashPassword(password); + } + + public String hashPassword(String password) { + return "hashed_" + password; + } +} +`, + 'src/service/Validator.java': `package service; + +public class Validator { + public boolean validate(String input) { + if (input == null || input.isEmpty()) { + throw new IllegalArgumentException("Invalid input"); + } + return true; + } + + public String sanitize(String input) { + return input.replaceAll("[<>]", ""); + } + + public boolean checkLength(String input, int max) { + return input.length() <= max; + } +} +`, + 'src/repository/UserRepository.java': `package repository; + +public class UserRepository extends BaseRepository { + public Object getById(String id) { + return new Object(); + } + + public Object save(String name) { + return new Object(); + } + + public boolean delete(String id) { + return true; + } +} +`, + 'src/repository/BaseRepository.java': `package repository; + +public abstract class BaseRepository { + public Object[] findAll() { + return new Object[0]; + } + + public int count() { + return 0; + } +} +`, + 'src/model/User.java': `package model; + +public class User { + private String name; + + public User(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * Java repo with service/repository/model clusters. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 6: Rust +// ============================================================================ + +describe('Rust', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('rust', { + 'Cargo.toml': `[package] +name = "testapp" +version = "0.1.0" +edition = "2021" +`, + 'src/main.rs': `mod auth; +mod data; + +fn main() { + let session = auth::login::login("user", "pass"); + let result = data::query::run_query("SELECT 1"); + println!("{:?} {:?}", session, result); +} +`, + 'src/auth/mod.rs': `pub mod login; +pub mod hash; +`, + 'src/auth/login.rs': `use crate::auth::hash::hash_password; + +pub fn login(username: &str, password: &str) -> String { + let hashed = hash_password(password); + format!("session_{}_{}", username, hashed) +} + +pub fn validate(token: &str) -> bool { + token.starts_with("session_") +} +`, + 'src/auth/hash.rs': `pub fn hash_password(password: &str) -> String { + format!("hashed_{}", password) +} + +pub fn compare_hash(plain: &str, hashed: &str) -> bool { + hash_password(plain) == hashed +} + +pub fn generate_salt() -> String { + String::from("random_salt") +} +`, + 'src/data/mod.rs': `pub mod query; +pub mod format; +`, + 'src/data/query.rs': `use crate::data::format::format_result; + +pub fn run_query(sql: &str) -> String { + let raw = format!("result_{}", sql); + format_result(&raw) +} + +pub fn build_query(table: &str) -> String { + format!("SELECT * FROM {}", table) +} +`, + 'src/data/format.rs': `pub fn format_result(data: &str) -> String { + format!("[formatted] {}", data) +} + +pub fn serialize(data: &str) -> String { + format!("{{\"data\": \"{}\"}}", data) +} + +pub fn format_error(err: &str) -> String { + format!("[ERROR] {}", err) +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * Rust repo with auth/data module clusters. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 7: C# +// ============================================================================ + +describe('CSharp', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('csharp', { + 'Services/UserService.cs': `using System; + +namespace Services +{ + public class UserService + { + public object FindUser(string id) + { + return id; + } + + public object CreateUser(string name) + { + return name; + } + + public object UpdateUser(string id, string name) + { + return name; + } + + public bool RemoveUser(string id) + { + return true; + } + } + + public class UserValidator + { + public bool ValidateUser(string input) + { + return true; + } + + public string SanitizeUser(string input) + { + return input; + } + + public bool CheckUserLength(string input) + { + return true; + } + } +} +`, + 'Services/AuthService.cs': `using System; + +namespace Services +{ + public class AuthService + { + public object Authenticate(string username, string password) + { + return username; + } + + public string HashPassword(string password) + { + return password; + } + + public bool VerifyPassword(string hashed) + { + return true; + } + + public string CreateToken(string username) + { + return username; + } + } + + public class TokenManager + { + public string GenerateToken(string user) + { + return user; + } + + public bool ValidateToken(string token) + { + return true; + } + + public string RefreshToken(string token) + { + return token; + } + } +} +`, + 'Services/OrderService.cs': `using System; + +namespace Services +{ + public class OrderService + { + public object CreateOrder(string item) + { + return item; + } + + public object GetOrder(string id) + { + return id; + } + + public bool CancelOrder(string id) + { + return true; + } + + public object UpdateOrder(string id, string item) + { + return item; + } + } + + public class OrderValidator + { + public bool ValidateOrder(string input) + { + return true; + } + + public string SanitizeOrder(string input) + { + return input; + } + } +} +`, + 'Services/EmailService.cs': `using System; + +namespace Services +{ + public class EmailService + { + public void SendMail(string to, string body) + { + } + + public void SendBulk(string to, string body) + { + } + + public string FormatBody(string body) + { + return body; + } + + public bool ValidateAddress(string addr) + { + return true; + } + } +} +`, + 'Data/UserRepo.cs': `using System; + +namespace Data +{ + public class UserRepo + { + public object GetById(string id) + { + return id; + } + + public object Save(string name) + { + return name; + } + + public object Update(string id, string name) + { + return name; + } + + public bool Delete(string id) + { + return true; + } + + public object[] ListAll() + { + return new object[0]; + } + } +} +`, + 'Data/OrderRepo.cs': `using System; + +namespace Data +{ + public class OrderRepo + { + public object FindOrder(string id) + { + return id; + } + + public object InsertOrder(string item) + { + return item; + } + + public bool RemoveOrder(string id) + { + return true; + } + + public object UpdateOrder(string id, string data) + { + return data; + } + + public int CountOrders() + { + return 0; + } + } +} +`, + 'Data/CacheManager.cs': `using System; + +namespace Data +{ + public class CacheManager + { + public object GetCached(string key) + { + return key; + } + + public void SetCached(string key, object val) + { + } + + public void Invalidate(string key) + { + } + + public void Clear() + { + } + } + + public class CacheStats + { + public int GetHitCount() + { + return 0; + } + + public int GetMissCount() + { + return 0; + } + + public double GetHitRate() + { + return 0.0; + } + } +} +`, + 'Data/Logger.cs': `using System; + +namespace Data +{ + public class Logger + { + public void Info(string msg) + { + } + + public void Error(string msg) + { + } + + public void Warn(string msg) + { + } + + public void Debug(string msg) + { + } + } + + public class LogFormatter + { + public string FormatEntry(string level, string msg) + { + return level + msg; + } + + public string FormatTimestamp() + { + return ""; + } + + public string FormatStackTrace(string trace) + { + return trace; + } + } +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * C# repo with Services/Data clusters. + * + * Note: tree-sitter-c-sharp's native N-API addon can crash in forked + * workers on some platforms (libc++abi exception). When this happens, + * the pipeline falls through with 0 communities and no skills are + * generated. assertSkillFiles handles this gracefully. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 8: C++ +// ============================================================================ + +describe('CPlusPlus', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('cpp', { + 'src/engine/engine.h': `#ifndef ENGINE_H +#define ENGINE_H + +class Engine { +public: + void start(); + void stop(); +}; + +#endif +`, + 'src/engine/engine.cpp': `#include "engine.h" +#include "../utils/logger.h" +#include "../utils/config.h" + +void Engine::start() { + Logger logger; + logger.log("Engine starting"); + Config config; + config.get("engine.mode"); +} + +void Engine::stop() { + Logger logger; + logger.log("Engine stopping"); +} +`, + 'src/engine/renderer.h': `#ifndef RENDERER_H +#define RENDERER_H + +class Renderer { +public: + void render(); + void clear(); +}; + +#endif +`, + 'src/engine/renderer.cpp': `#include "renderer.h" +#include "engine.h" + +void Renderer::render() { + Engine engine; + engine.start(); +} + +void Renderer::clear() { +} +`, + 'src/engine/physics.h': `#ifndef PHYSICS_H +#define PHYSICS_H + +void simulate(); +void collide(); + +#endif +`, + 'src/engine/physics.cpp': `#include "physics.h" +#include "engine.h" +#include "../utils/logger.h" + +void simulate() { + Engine engine; + engine.stop(); + Logger logger; + logger.log("simulating"); +} + +void collide() { + Logger logger; + logger.log("collision detected"); +} +`, + 'src/utils/logger.h': `#ifndef LOGGER_H +#define LOGGER_H + +#include <string> + +class Logger { +public: + void log(const std::string& msg); + void error(const std::string& msg); + void flush(); +}; + +#endif +`, + 'src/utils/logger.cpp': `#include "logger.h" +#include <iostream> + +void Logger::log(const std::string& msg) { + std::cout << "[LOG] " << msg << std::endl; +} + +void Logger::error(const std::string& msg) { + std::cerr << "[ERR] " << msg << std::endl; +} + +void Logger::flush() { + std::cout.flush(); +} +`, + 'src/utils/config.h': `#ifndef CONFIG_H +#define CONFIG_H + +#include <string> + +class Config { +public: + std::string get(const std::string& key); + void set(const std::string& key, const std::string& value); + void load(const std::string& path); +}; + +#endif +`, + 'src/utils/config.cpp': `#include "config.h" + +std::string Config::get(const std::string& key) { + return ""; +} + +void Config::set(const std::string& key, const std::string& value) { +} + +void Config::load(const std::string& path) { +} +`, + 'src/utils/math.h': `#ifndef MATH_H +#define MATH_H + +int clamp(int value, int min, int max); +float lerp(float a, float b, float t); +double distance(double x1, double y1, double x2, double y2); + +#endif +`, + 'src/utils/math.cpp': `#include "math.h" +#include <cmath> + +int clamp(int value, int min, int max) { + if (value < min) return min; + if (value > max) return max; + return value; +} + +float lerp(float a, float b, float t) { + return a + (b - a) * t; +} + +double distance(double x1, double y1, double x2, double y2) { + return std::sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)); +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * C++ repo with engine/utils clusters including headers. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 9: C +// ============================================================================ + +describe('C', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('c', { + 'src/core/parser.h': `#ifndef PARSER_H +#define PARSER_H + +void parse(const char* input); +void tokenize(const char* input); + +#endif +`, + 'src/core/parser.c': `#include "parser.h" +#include "../io/reader.h" +#include "../io/logger.h" + +void parse(const char* input) { + char* data = read_file(input); + log_msg("parsing"); + tokenize(data); +} + +void tokenize(const char* input) { + log_msg("tokenizing"); +} +`, + 'src/core/lexer.h': `#ifndef LEXER_H +#define LEXER_H + +typedef struct { + int type; + const char* value; +} Token; + +void lex(const char* input); +Token next_token(const char* input); +int is_keyword(const char* word); + +#endif +`, + 'src/core/lexer.c': `#include "lexer.h" +#include "parser.h" +#include <string.h> + +void lex(const char* input) { + parse(input); +} + +Token next_token(const char* input) { + Token t; + t.type = 0; + t.value = input; + return t; +} + +int is_keyword(const char* word) { + return strcmp(word, "if") == 0 || strcmp(word, "else") == 0; +} +`, + 'src/core/ast.h': `#ifndef AST_H +#define AST_H + +typedef struct ASTNode { + int type; + struct ASTNode* left; + struct ASTNode* right; +} ASTNode; + +ASTNode* create_node(int type); +void free_node(ASTNode* node); + +#endif +`, + 'src/core/ast.c': `#include "ast.h" +#include "lexer.h" +#include <stdlib.h> + +ASTNode* create_node(int type) { + ASTNode* node = (ASTNode*)malloc(sizeof(ASTNode)); + node->type = type; + node->left = NULL; + node->right = NULL; + tokenize("ast"); + return node; +} + +void free_node(ASTNode* node) { + if (node) { + free_node(node->left); + free_node(node->right); + free(node); + } +} +`, + 'src/io/reader.h': `#ifndef READER_H +#define READER_H + +char* read_file(const char* path); +void close_file(const char* path); +int file_exists(const char* path); + +#endif +`, + 'src/io/reader.c': `#include "reader.h" +#include <stdio.h> +#include <stdlib.h> + +char* read_file(const char* path) { + return "file contents"; +} + +void close_file(const char* path) { +} + +int file_exists(const char* path) { + FILE* f = fopen(path, "r"); + if (f) { fclose(f); return 1; } + return 0; +} +`, + 'src/io/writer.h': `#ifndef WRITER_H +#define WRITER_H + +void write_file(const char* path, const char* data); +void flush_writer(void); + +#endif +`, + 'src/io/writer.c': `#include "writer.h" +#include "logger.h" + +void write_file(const char* path, const char* data) { + log_msg("writing file"); +} + +void flush_writer(void) { + log_msg("flushing"); +} +`, + 'src/io/logger.h': `#ifndef LOGGER_H +#define LOGGER_H + +void log_msg(const char* msg); +void log_error(const char* msg); +void log_init(void); + +#endif +`, + 'src/io/logger.c': `#include "logger.h" +#include <stdio.h> + +void log_msg(const char* msg) { + printf("[LOG] %s\\n", msg); +} + +void log_error(const char* msg) { + fprintf(stderr, "[ERR] %s\\n", msg); +} + +void log_init(void) { + log_msg("logger initialized"); +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * C repo with core/io clusters including headers. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 10: PHP +// ============================================================================ + +describe('PHP', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('php', { + 'src/Controllers/UserController.php': `<?php + +function controller_index() { + validate_input('list'); + $users = service_find_all(); + return format_response($users); +} + +function controller_store($data) { + validate_input($data); + sanitize_input($data); + $user = service_find_by_id($data); + return format_response($user); +} + +function controller_update($id, $data) { + validate_input($id); + validate_input($data); + $result = service_update($id, $data); + return format_response($result); +} + +function controller_delete($id) { + validate_input($id); + return service_delete($id); +} +`, + 'src/Controllers/AuthController.php': `<?php + +function auth_login($username, $password) { + validate_input($username); + validate_input($password); + $hash = auth_hash_password($password); + return auth_create_token($username); +} + +function auth_logout($token) { + validate_input($token); + return true; +} + +function auth_register($username, $password) { + validate_input($username); + sanitize_input($username); + $hash = auth_hash_password($password); + return service_create($username, $hash); +} +`, + 'src/Controllers/ApiController.php': `<?php + +function api_handle_request($method, $path) { + validate_input($method); + validate_input($path); + log_request($method . ' ' . $path); + return format_response(['method' => $method, 'path' => $path]); +} + +function api_handle_error($error) { + log_error($error); + return format_error($error); +} + +function api_middleware($request) { + validate_input($request); + log_request('middleware'); + return true; +} +`, + 'src/Services/UserService.php': `<?php + +function service_find_all() { + $result = db_query('SELECT * FROM users'); + return format_response($result); +} + +function service_find_by_id($id) { + $result = db_query('SELECT * FROM users WHERE id = ' . $id); + return format_response($result); +} + +function service_create($name, $hash) { + db_execute('INSERT INTO users VALUES (' . $name . ')'); + log_request('user created'); + return true; +} + +function service_update($id, $data) { + db_execute('UPDATE users SET data = ' . $data); + log_request('user updated'); + return true; +} + +function service_delete($id) { + db_execute('DELETE FROM users WHERE id = ' . $id); + log_request('user deleted'); + return true; +} +`, + 'src/Services/AuthServiceImpl.php': `<?php + +function auth_hash_password($password) { + validate_input($password); + return 'hashed_' . $password; +} + +function auth_create_token($username) { + validate_input($username); + log_request('token created for ' . $username); + return 'token_' . $username; +} + +function auth_verify_token($token) { + validate_input($token); + return strpos($token, 'token_') === 0; +} + +function auth_refresh_token($token) { + auth_verify_token($token); + return auth_create_token('refreshed'); +} +`, + 'src/Helpers/validator.php': `<?php + +function validate_input($input) { + if (empty($input)) { + throw new InvalidArgumentException('Invalid'); + } + return true; +} + +function sanitize_input($input) { + return htmlspecialchars($input); +} + +function check_required($data, $fields) { + foreach ($fields as $field) { + if (!isset($data[$field])) return false; + } + return true; +} + +function check_length($input, $max = 255) { + return strlen($input) <= $max; +} +`, + 'src/Helpers/logger.php': `<?php + +function log_request($msg) { + echo '[REQ] ' . $msg . "\\n"; +} + +function log_error($msg) { + echo '[ERR] ' . $msg . "\\n"; +} + +function log_info($msg) { + echo '[INFO] ' . $msg . "\\n"; +} + +function create_log_entry($level, $msg) { + return ['level' => $level, 'msg' => $msg, 'ts' => time()]; +} +`, + 'src/Helpers/formatter.php': `<?php + +function format_response($data) { + return ['status' => 200, 'body' => $data, 'formatted' => true]; +} + +function format_error($err) { + return ['status' => 500, 'error' => $err]; +} + +function format_date($timestamp) { + return date('Y-m-d', $timestamp); +} + +function format_json($data) { + return json_encode($data); +} +`, + 'src/Data/database.php': `<?php + +function db_query($sql) { + log_request('query: ' . $sql); + return []; +} + +function db_execute($sql) { + log_request('execute: ' . $sql); + return true; +} + +function db_connect($host) { + return true; +} + +function db_close() { + return true; +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * PHP repo with Controllers/Services/Models clusters. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 11: Kotlin +// ============================================================================ + +describe('Kotlin', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('kotlin', { + 'src/main/kotlin/service/UserService.kt': `package service + +fun findUser(id: String): Map<String, Any> { + validateInput(id) + val result = dbQuery("SELECT * FROM users WHERE id = $id") + return formatResponse(result) +} + +fun createUser(name: String): Map<String, Any> { + validateInput(name) + sanitizeInput(name) + dbExecute("INSERT INTO users VALUES ('$name')") + logRequest("user created") + return formatResponse(mapOf("name" to name)) +} + +fun updateUser(id: String, name: String): Map<String, Any> { + validateInput(id) + validateInput(name) + dbExecute("UPDATE users SET name = '$name' WHERE id = $id") + logRequest("user updated") + return formatResponse(mapOf("id" to id)) +} + +fun deleteUser(id: String): Boolean { + validateInput(id) + dbExecute("DELETE FROM users WHERE id = $id") + logRequest("user deleted") + return true +} +`, + 'src/main/kotlin/service/AuthService.kt': `package service + +fun authenticate(username: String, password: String): Map<String, Any> { + validateInput(username) + validateInput(password) + val user = findUser(username) + val hash = hashPassword(password) + return formatResponse(mapOf("user" to user, "token" to createToken(username))) +} + +fun hashPassword(password: String): String { + validateInput(password) + return "hashed_$password" +} + +fun createToken(username: String): String { + validateInput(username) + logRequest("token created for $username") + return "token_$username" +} + +fun verifyToken(token: String): Boolean { + validateInput(token) + return token.startsWith("token_") +} + +fun refreshToken(token: String): String { + verifyToken(token) + return createToken("refreshed") +} +`, + 'src/main/kotlin/service/NotificationService.kt': `package service + +fun notify(userId: String, message: String) { + validateInput(userId) + validateInput(message) + sendEmail(userId, message) +} + +fun sendEmail(to: String, body: String) { + sanitizeInput(body) + logRequest("email sent to $to") + formatMessage(body) +} + +fun sendAlert(message: String) { + logRequest("alert: $message") + formatError(message) +} +`, + 'src/main/kotlin/helpers/Validator.kt': `package helpers + +fun validateInput(input: String): Boolean { + if (input.isEmpty()) throw IllegalArgumentException("Invalid") + return true +} + +fun sanitizeInput(input: String): String { + return input.replace("<", "").replace(">", "") +} + +fun checkLength(input: String, max: Int = 255): Boolean { + return input.length <= max +} + +fun normalizeInput(input: String): String { + return input.trim().lowercase() +} +`, + 'src/main/kotlin/helpers/Logger.kt': `package helpers + +fun logRequest(msg: String) { + println("[REQ] $msg") +} + +fun logError(msg: String) { + System.err.println("[ERR] $msg") +} + +fun logInfo(msg: String) { + println("[INFO] $msg") +} + +fun createLogEntry(level: String, msg: String): Map<String, Any> { + return mapOf("level" to level, "msg" to msg, "ts" to System.currentTimeMillis()) +} +`, + 'src/main/kotlin/helpers/Formatter.kt': `package helpers + +fun formatResponse(data: Map<String, Any>): Map<String, Any> { + return data + mapOf("formatted" to true, "status" to 200) +} + +fun formatError(err: String): Map<String, Any> { + return mapOf("status" to 500, "error" to err) +} + +fun formatMessage(msg: String): String { + return "[MSG] $msg" +} + +fun formatDate(timestamp: Long): String { + return timestamp.toString() +} +`, + 'src/main/kotlin/data/Database.kt': `package data + +fun dbQuery(sql: String): Map<String, Any> { + logRequest("query: $sql") + return mapOf("rows" to emptyList<Any>()) +} + +fun dbExecute(sql: String): Boolean { + logRequest("execute: $sql") + return true +} + +fun dbConnect(url: String): Boolean { + return true +} + +fun dbClose() { +} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates valid SKILL.md files for a + * Kotlin repo with service/repository clusters. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 12: Mixed TypeScript + Python +// ============================================================================ + +describe('Mixed TypeScript + Python', () => { + let tmpDir: string; + let result: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('mixed', { + 'packages/backend/src/api/router.ts': ` +import { validateRequest } from '../utils/validator'; +import { logRequest } from '../utils/logger'; + +export function createRouter() { + validateRequest('route'); + logRequest('router init'); + return { routes: [] }; +} + +export function registerRoute(path: string) { + validateRequest(path); + logRequest('register ' + path); + return true; +} +`, + 'packages/backend/src/api/controller.ts': ` +import { runQuery } from '../data/query'; + +export function handleGet(id: string) { + return runQuery('SELECT * FROM items WHERE id = ' + id); +} + +export function handlePost(body: any) { + return runQuery('INSERT INTO items VALUES ' + JSON.stringify(body)); +} +`, + 'packages/backend/src/data/query.ts': ` +export function runQuery(sql: string) { + return { sql, rows: [] }; +} + +export function buildQuery(table: string) { + return 'SELECT * FROM ' + table; +} +`, + 'packages/backend/src/utils/validator.ts': ` +export function validateRequest(input: string) { + if (!input) throw new Error('Invalid'); + return true; +} + +export function sanitize(input: string) { + return input.replace(/[<>]/g, ''); +} +`, + 'packages/backend/src/utils/logger.ts': ` +export function logRequest(msg: string) { + console.log('[REQ]', msg); +} + +export function logError(msg: string) { + console.error('[ERR]', msg); +} +`, + 'packages/ml/src/pipeline/__init__.py': '', + 'packages/ml/src/pipeline/train.py': ` +from packages.ml.src.data.loader import load_data, preprocess + +def train(config): + data = load_data("train.csv") + processed = preprocess(data) + return {"model": "trained", "data": processed} + +def evaluate(model, test_data): + data = load_data("test.csv") + return {"accuracy": 0.95} +`, + 'packages/ml/src/pipeline/predict.py': ` +from packages.ml.src.models.model import load_model + +def predict(input_data): + model = load_model("latest") + return {"prediction": "result"} + +def batch_predict(inputs): + model = load_model("latest") + return [{"prediction": "result"} for _ in inputs] +`, + 'packages/ml/src/data/__init__.py': '', + 'packages/ml/src/data/loader.py': ` +def load_data(path): + return {"path": path, "rows": []} + +def preprocess(data): + return {**data, "preprocessed": True} + +def split_data(data, ratio=0.8): + return data, data +`, + 'packages/ml/src/models/__init__.py': '', + 'packages/ml/src/models/model.py': ` +def load_model(name): + return {"name": name, "loaded": True} + +def save_model(model, path): + return True + +def compile_model(config): + return {"compiled": True} +`, + }); + result = runSkillsCli(tmpDir); + }, 50000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Verify analyze --skills generates at least 1 SKILL.md for a + * mixed TypeScript + Python monorepo. Relaxed assertion since Leiden + * may or may not form communities spanning both languages. + */ + it('generates skill files', () => { + assertSkillFiles(result, tmpDir, 1); + }, 50000); + + /** + * Verify CLAUDE.md and AGENTS.md are created and reference generated skills. + */ + it('context files updated', () => { + assertContextFiles(result, tmpDir); + }, 50000); +}); + +// ============================================================================ +// DESCRIBE 13: Idempotency +// ============================================================================ + +describe('Idempotency', () => { + let tmpDir: string; + let result1: ReturnType<typeof runSkillsCli>; + let result2: ReturnType<typeof runSkillsCli>; + + beforeAll(() => { + tmpDir = createFixtureRepo('idempotency', { + 'src/core/parser.ts': ` +import { readFile } from '../io/reader'; +import { log } from '../io/logger'; + +export function parse(input: string) { + const data = readFile(input); + log('parsing'); + return tokenize(data); +} + +export function tokenize(data: string) { + log('tokenizing'); + return data.split(' '); +} +`, + 'src/core/transformer.ts': ` +import { parse } from './parser'; +import { validate } from './validator'; + +export function transform(input: string) { + validate(input); + const tokens = parse(input); + return tokens.map(t => t.toUpperCase()); +} + +export function optimize(input: string) { + const tokens = parse(input); + return tokens.filter(t => t.length > 0); +} +`, + 'src/core/validator.ts': ` +export function validate(input: string) { + if (!input) throw new Error('Invalid'); + return true; +} + +export function checkSchema(schema: any) { + return schema && typeof schema === 'object'; +} + +export function sanitize(input: string) { + return input.replace(/[<>]/g, ''); +} +`, + 'src/io/reader.ts': ` +export function readFile(path: string) { + return 'file contents from ' + path; +} + +export function readStream(path: string) { + return { path, stream: true }; +} + +export function close(handle: any) { + return true; +} +`, + 'src/io/writer.ts': ` +import { log } from './logger'; + +export function writeFile(path: string, data: string) { + log('writing ' + path); + return true; +} + +export function flush() { + log('flushing'); + return true; +} +`, + 'src/io/logger.ts': ` +export function log(msg: string) { + console.log('[LOG]', msg); +} + +export function logError(msg: string) { + console.error('[ERR]', msg); +} + +export function createEntry(level: string, msg: string) { + return { level, msg, ts: Date.now() }; +} +`, + }); + result1 = runSkillsCli(tmpDir); + result2 = runSkillsCli(tmpDir); + }, 90000); + + afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + + /** + * Running analyze --skills twice should produce stable output: + * same number of skill directories, all SKILL.md files valid, + * and CLAUDE.md still references generated skills. + */ + it('second analyze --skills produces stable output', () => { + /* CI timeout tolerance */ + if (result1.status === null || result2.status === null) return; + + expect(result1.status).toBe(0); + expect(result2.status).toBe(0); + + const generatedDir = path.join(tmpDir, '.claude', 'skills', 'generated'); + expect(fs.existsSync(generatedDir)).toBe(true); + + const skillDirs = fs.readdirSync(generatedDir).filter(d => + fs.statSync(path.join(generatedDir, d)).isDirectory(), + ); + expect(skillDirs.length).toBeGreaterThanOrEqual(1); + + /* All SKILL.md files should still have valid frontmatter */ + for (const dir of skillDirs) { + const skillPath = path.join(generatedDir, dir, 'SKILL.md'); + expect(fs.existsSync(skillPath)).toBe(true); + const content = fs.readFileSync(skillPath, 'utf-8'); + expect(content.startsWith('---')).toBe(true); + expect(content).toContain('name:'); + expect(content).toContain('description:'); + expect(content.length).toBeGreaterThan(200); + } + + /* CLAUDE.md should still reference generated skills */ + const claudePath = path.join(tmpDir, 'CLAUDE.md'); + expect(fs.existsSync(claudePath)).toBe(true); + const claudeContent = fs.readFileSync(claudePath, 'utf-8'); + expect(claudeContent).toContain('.claude/skills/generated/'); + }, 90000); +}); diff --git a/gitnexus/test/integration/tree-sitter-languages.test.ts b/gitnexus/test/integration/tree-sitter-languages.test.ts new file mode 100644 index 0000000000..6faa8eecd2 --- /dev/null +++ b/gitnexus/test/integration/tree-sitter-languages.test.ts @@ -0,0 +1,447 @@ +import { describe, it, expect, beforeAll } from 'vitest'; +import fs from 'fs'; +import path from 'path'; +import { loadParser, loadLanguage } from '../../src/core/tree-sitter/parser-loader.js'; +import { LANGUAGE_QUERIES } from '../../src/core/ingestion/tree-sitter-queries.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; +import { getLanguageFromFilename } from '../../src/core/ingestion/utils.js'; +import Parser from 'tree-sitter'; + +const fixturesDir = path.resolve(__dirname, '..', 'fixtures', 'sample-code'); + +function readFixture(filename: string): string { + return fs.readFileSync(path.join(fixturesDir, filename), 'utf-8'); +} + +function parseAndQuery(parser: Parser, content: string, queryStr: string) { + const tree = parser.parse(content); + const lang = parser.getLanguage(); + const query = new Parser.Query(lang, queryStr); + const matches = query.matches(tree.rootNode); + return { tree, matches }; +} + +function extractDefinitions(matches: any[]) { + const defs: { type: string; name: string }[] = []; + for (const match of matches) { + for (const capture of match.captures) { + if (capture.name === 'name' && match.captures.some((c: any) => + c.name.startsWith('definition.'))) { + const defType = match.captures.find((c: any) => c.name.startsWith('definition.'))!.name; + defs.push({ type: defType, name: capture.node.text }); + } + } + } + return defs; +} + +describe('Tree-sitter multi-language parsing', () => { + let parser: Parser; + + beforeAll(async () => { + parser = await loadParser(); + }); + + describe('TypeScript', () => { + it('parses functions, classes, interfaces, methods, and arrow functions', async () => { + await loadLanguage(SupportedLanguages.TypeScript, 'simple.ts'); + const content = readFixture('simple.ts'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.TypeScript]); + const defs = extractDefinitions(matches); + + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.class'); + expect(defTypes).toContain('definition.function'); + }); + }); + + describe('TSX', () => { + it('parses JSX components with tsx grammar', async () => { + await loadLanguage(SupportedLanguages.TypeScript, 'simple.tsx'); + const content = readFixture('simple.tsx'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.TypeScript]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + // Should detect Counter class and Button/useCounter functions + const names = defs.map(d => d.name); + expect(names).toContain('Counter'); + }); + }); + + describe('JavaScript', () => { + it('parses class and function declarations', async () => { + await loadLanguage(SupportedLanguages.JavaScript); + const content = readFixture('simple.js'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.JavaScript]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + const names = defs.map(d => d.name); + expect(names).toContain('EventEmitter'); + expect(names).toContain('createLogger'); + }); + }); + + describe('Python', () => { + it('parses class and function definitions', async () => { + await loadLanguage(SupportedLanguages.Python); + const content = readFixture('simple.py'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.Python]); + const defs = extractDefinitions(matches); + + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.class'); + expect(defTypes).toContain('definition.function'); + }); + }); + + describe('Java', () => { + it('parses class, method, and constructor declarations', async () => { + await loadLanguage(SupportedLanguages.Java); + const content = readFixture('simple.java'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.Java]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.class'); + expect(defTypes).toContain('definition.method'); + }); + }); + + describe('Go', () => { + it('parses function and type declarations', async () => { + await loadLanguage(SupportedLanguages.Go); + const content = readFixture('simple.go'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.Go]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.function'); + }); + }); + + describe('C', () => { + it('parses function definitions and structs', async () => { + await loadLanguage(SupportedLanguages.C); + const content = readFixture('simple.c'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.C]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.function'); + const names = defs.map(d => d.name); + expect(names).toContain('add'); + expect(names).toContain('internal_helper'); + expect(names).toContain('print_message'); + }); + + it('captures pointer-returning function definitions', async () => { + await loadLanguage(SupportedLanguages.C); + const code = `int* get_ptr() { return 0; }\nchar** get_strs() { return 0; }`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.C]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('get_ptr'); + expect(names).toContain('get_strs'); + }); + + it('captures macros and typedefs', async () => { + await loadLanguage(SupportedLanguages.C); + const code = `#define MAX_SIZE 100\ntypedef unsigned int uint;\nstruct Point { int x; int y; };`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.C]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('MAX_SIZE'); + expect(names).toContain('uint'); + expect(names).toContain('Point'); + }); + }); + + describe('C++', () => { + it('parses class, function, and namespace declarations', async () => { + await loadLanguage(SupportedLanguages.CPlusPlus); + const content = readFixture('simple.cpp'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.CPlusPlus]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.class'); + const names = defs.map(d => d.name); + expect(names).toContain('UserManager'); + expect(names).toContain('helperFunction'); + }); + + it('captures pointer-returning methods and functions', async () => { + await loadLanguage(SupportedLanguages.CPlusPlus); + const code = `int* Factory::create() { return nullptr; }\nchar** getNames() { return 0; }`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.CPlusPlus]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('create'); + expect(names).toContain('getNames'); + }); + + it('captures reference-returning functions', async () => { + await loadLanguage(SupportedLanguages.CPlusPlus); + const code = `int& Container::at(int i) { static int x; return x; }`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.CPlusPlus]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('at'); + }); + + it('captures destructor definitions', async () => { + await loadLanguage(SupportedLanguages.CPlusPlus); + const code = `MyClass::~MyClass() { cleanup(); }`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.CPlusPlus]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('~MyClass'); + }); + + it('captures template declarations', async () => { + await loadLanguage(SupportedLanguages.CPlusPlus); + const code = `template<typename T> class Container { T value; };`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.CPlusPlus]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('Container'); + }); + + it('captures namespace definitions', async () => { + await loadLanguage(SupportedLanguages.CPlusPlus); + const code = `namespace utils { void helper() {} }`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.CPlusPlus]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('utils'); + expect(names).toContain('helper'); + }); + }); + + describe('C#', () => { + it('parses class, method, and namespace declarations', async () => { + await loadLanguage(SupportedLanguages.CSharp); + const content = readFixture('simple.cs'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.CSharp]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.class'); + expect(defTypes).toContain('definition.method'); + expect(defTypes).toContain('definition.namespace'); + const names = defs.map(d => d.name); + expect(names).toContain('Calculator'); + expect(names).toContain('Add'); + }); + + it('captures interfaces, enums, records, structs', async () => { + await loadLanguage(SupportedLanguages.CSharp); + const content = readFixture('simple.cs'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.CSharp]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('ICalculator'); + expect(names).toContain('Operation'); + expect(names).toContain('CalculationResult'); + expect(names).toContain('Point'); + }); + + it('captures file-scoped namespace declarations', async () => { + await loadLanguage(SupportedLanguages.CSharp); + const code = `namespace MyApp;\npublic class Program { }`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.CSharp]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('MyApp'); + expect(names).toContain('Program'); + }); + + it('captures constructors and properties', async () => { + await loadLanguage(SupportedLanguages.CSharp); + const content = readFixture('simple.cs'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.CSharp]); + const defs = extractDefinitions(matches); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.constructor'); + expect(defTypes).toContain('definition.property'); + }); + }); + + describe('Rust', () => { + it('parses fn, struct, impl, trait, and enum', async () => { + await loadLanguage(SupportedLanguages.Rust); + const content = readFixture('simple.rs'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.Rust]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.function'); + const names = defs.map(d => d.name); + expect(names).toContain('public_function'); + expect(names).toContain('private_function'); + expect(names).toContain('Config'); + }); + + it('captures impl blocks and methods', async () => { + await loadLanguage(SupportedLanguages.Rust); + const content = readFixture('simple.rs'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.Rust]); + const defs = extractDefinitions(matches); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.impl'); + const names = defs.map(d => d.name); + expect(names).toContain('new'); + }); + + it('captures generic impl blocks', async () => { + await loadLanguage(SupportedLanguages.Rust); + const code = `struct Vec<T> { data: Vec<T> }\nimpl<T> Vec<T> { fn len(&self) -> usize { 0 } }`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.Rust]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('Vec'); + }); + + it('captures trait impl heritage', async () => { + await loadLanguage(SupportedLanguages.Rust); + const code = `trait Display { fn fmt(&self); }\nstruct Foo;\nimpl Display for Foo { fn fmt(&self) {} }`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.Rust]); + // Look for heritage captures + const heritageCaptures: string[] = []; + for (const match of matches) { + for (const capture of match.captures) { + if (capture.name.startsWith('heritage.')) { + heritageCaptures.push(`${capture.name}:${capture.node.text}`); + } + } + } + expect(heritageCaptures).toContain('heritage.trait:Display'); + expect(heritageCaptures).toContain('heritage.class:Foo'); + }); + + it('captures modules, consts, and statics', async () => { + await loadLanguage(SupportedLanguages.Rust); + const code = `mod utils { pub fn helper() {} }\npub const MAX: usize = 100;\nstatic INSTANCE: i32 = 0;`; + const { matches } = parseAndQuery(parser, code, LANGUAGE_QUERIES[SupportedLanguages.Rust]); + const defs = extractDefinitions(matches); + const names = defs.map(d => d.name); + expect(names).toContain('utils'); + expect(names).toContain('MAX'); + expect(names).toContain('INSTANCE'); + }); + }); + + describe('PHP', () => { + it('parses class, function, and method declarations', async () => { + await loadLanguage(SupportedLanguages.PHP); + const content = readFixture('simple.php'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.PHP]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + const defTypes = defs.map(d => d.type); + expect(defTypes).toContain('definition.class'); + }); + }); + + describe('Swift', () => { + it('parses class, struct, protocol, and function if tree-sitter-swift is available', async () => { + try { + await loadLanguage(SupportedLanguages.Swift); + } catch { + // tree-sitter-swift not installed — skip + return; + } + + const content = readFixture('simple.swift'); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[SupportedLanguages.Swift]); + const defs = extractDefinitions(matches); + + expect(defs.length).toBeGreaterThan(0); + }); + + it('gracefully handles missing tree-sitter-swift', async () => { + // If Swift is NOT available, loadLanguage should throw + // If it IS available, this test just passes + try { + await loadLanguage(SupportedLanguages.Swift); + } catch (e: any) { + expect(e.message).toContain('Unsupported language'); + } + }); + }); + + describe('unhappy path', () => { + it('returns null/undefined for unsupported file extensions', () => { + expect(getLanguageFromFilename('archive.xyz')).toBeNull(); + expect(getLanguageFromFilename('data.unknown')).toBeNull(); + }); + + it('handles empty string file path', () => { + expect(getLanguageFromFilename('')).toBeNull(); + }); + + it('returns null/undefined for binary file extensions', () => { + expect(getLanguageFromFilename('program.exe')).toBeNull(); + expect(getLanguageFromFilename('library.dll')).toBeNull(); + expect(getLanguageFromFilename('object.so')).toBeNull(); + }); + }); + + describe('cross-language assertions', () => { + it('all supported languages produce at least one definition from fixtures', async () => { + const langFixtures: [SupportedLanguages, string, string?][] = [ + [SupportedLanguages.TypeScript, 'simple.ts'], + [SupportedLanguages.JavaScript, 'simple.js'], + [SupportedLanguages.Python, 'simple.py'], + [SupportedLanguages.Java, 'simple.java'], + [SupportedLanguages.Go, 'simple.go'], + [SupportedLanguages.C, 'simple.c'], + [SupportedLanguages.CPlusPlus, 'simple.cpp'], + [SupportedLanguages.CSharp, 'simple.cs'], + [SupportedLanguages.Rust, 'simple.rs'], + [SupportedLanguages.PHP, 'simple.php'], + ]; + + for (const [lang, fixture, filePath] of langFixtures) { + await loadLanguage(lang, filePath || fixture); + const content = readFixture(fixture); + const { matches } = parseAndQuery(parser, content, LANGUAGE_QUERIES[lang]); + const defs = extractDefinitions(matches); + expect(defs.length, `${lang} (${fixture}) should have definitions`).toBeGreaterThan(0); + } + }); + }); + + describe('parser edge cases', () => { + it('loadLanguage throws for unsupported language', async () => { + await expect(loadLanguage('brainfuck' as any)).rejects.toThrow(/unsupported language/i); + }); + + it('parsing empty file content produces empty matches', async () => { + await loadLanguage(SupportedLanguages.TypeScript, 'empty.ts'); + const tree = parser.parse(''); + expect(tree.rootNode).toBeDefined(); + + const lang = parser.getLanguage(); + const query = new Parser.Query(lang, LANGUAGE_QUERIES[SupportedLanguages.TypeScript]); + const matches = query.matches(tree.rootNode); + expect(matches).toEqual([]); + }); + + it('parsing malformed code does not crash', async () => { + await loadLanguage(SupportedLanguages.TypeScript, 'malformed.ts'); + const tree = parser.parse('function {{{ class >>><< if(( end'); + expect(tree.rootNode).toBeDefined(); + expect(tree.rootNode.hasError).toBe(true); + }); + }); +}); diff --git a/gitnexus/test/integration/worker-pool.test.ts b/gitnexus/test/integration/worker-pool.test.ts new file mode 100644 index 0000000000..d86c2cb585 --- /dev/null +++ b/gitnexus/test/integration/worker-pool.test.ts @@ -0,0 +1,176 @@ +/** + * Integration Tests: Worker Pool & Parse Worker + * + * Verifies that the worker pool can spawn real worker threads using the + * compiled dist/ parse-worker.js and process files correctly. + * This is critical for cross-platform CI where vitest runs from src/ + * but workers need compiled .js files. + */ +import { describe, it, expect, afterEach } from 'vitest'; +import { createWorkerPool, WorkerPool } from '../../src/core/ingestion/workers/worker-pool.js'; +import { pathToFileURL } from 'node:url'; +import path from 'node:path'; +import fs from 'node:fs'; + +const DIST_WORKER = path.resolve(__dirname, '..', '..', 'dist', 'core', 'ingestion', 'workers', 'parse-worker.js'); +const hasDistWorker = fs.existsSync(DIST_WORKER); + +describe('worker pool integration', () => { + let pool: WorkerPool | undefined; + + afterEach(async () => { + if (pool) { + await pool.terminate(); + pool = undefined; + } + }); + + it.skipIf(!hasDistWorker)('creates a worker pool from dist/ worker', () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 1); + expect(pool.size).toBe(1); + }); + + it.skipIf(!hasDistWorker)('dispatches an empty batch without error', async () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 1); + const results = await pool.dispatch([]); + expect(results).toEqual([]); + }); + + it.skipIf(!hasDistWorker)('parses a single TypeScript file through worker', async () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 1); + + const fixtureFile = path.resolve(__dirname, '..', 'fixtures', 'mini-repo', 'src', 'validator.ts'); + const content = fs.readFileSync(fixtureFile, 'utf-8'); + + const results = await pool.dispatch<any, any>([ + { path: 'src/validator.ts', content }, + ]); + + // Worker returns an array of results (one per worker chunk) + expect(results).toHaveLength(1); + const result = results[0]; + expect(result.fileCount).toBe(1); + expect(result.nodes.length).toBeGreaterThan(0); + + // Should find the validateInput function + const names = result.nodes.map((n: any) => n.properties.name); + expect(names).toContain('validateInput'); + }); + + it.skipIf(!hasDistWorker)('parses multiple files across workers', async () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 2); + + const fixturesDir = path.resolve(__dirname, '..', 'fixtures', 'mini-repo', 'src'); + const files = fs.readdirSync(fixturesDir) + .filter(f => f.endsWith('.ts')) + .map(f => ({ + path: `src/${f}`, + content: fs.readFileSync(path.join(fixturesDir, f), 'utf-8'), + })); + + expect(files.length).toBeGreaterThanOrEqual(4); + + const results = await pool.dispatch<any, any>(files); + + // Each worker chunk returns a result + expect(results.length).toBeGreaterThan(0); + + // Total files parsed should match input + const totalParsed = results.reduce((sum: number, r: any) => sum + r.fileCount, 0); + expect(totalParsed).toBe(files.length); + + // Should find symbols from multiple files + const allNames = results.flatMap((r: any) => r.nodes.map((n: any) => n.properties.name)); + expect(allNames).toContain('handleRequest'); + expect(allNames).toContain('validateInput'); + expect(allNames).toContain('saveToDb'); + expect(allNames).toContain('formatResponse'); + }); + + it.skipIf(!hasDistWorker)('reports progress during parsing', async () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 1); + + const fixturesDir = path.resolve(__dirname, '..', 'fixtures', 'mini-repo', 'src'); + const files = fs.readdirSync(fixturesDir) + .filter(f => f.endsWith('.ts')) + .map(f => ({ + path: `src/${f}`, + content: fs.readFileSync(path.join(fixturesDir, f), 'utf-8'), + })); + + const progressCalls: number[] = []; + await pool.dispatch<any, any>(files, (filesProcessed) => { + progressCalls.push(filesProcessed); + }); + + // Progress callbacks are best-effort — with a small batch the worker may + // process all files before the progress message is delivered. Just verify + // that if progress was reported, the values are sensible. + if (progressCalls.length > 0) { + expect(progressCalls[progressCalls.length - 1]).toBe(files.length); + } + }); + + it.skipIf(!hasDistWorker)('terminates cleanly', async () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 2); + await pool.terminate(); + pool = undefined; // already terminated + }); + + it('fails gracefully with invalid worker path', () => { + const badUrl = pathToFileURL('/nonexistent/worker.js') as URL; + // createWorkerPool validates the worker script exists before spawning + expect(() => { + pool = createWorkerPool(badUrl, 1); + }).toThrow(/Worker script not found/); + }); + + // ─── Unhappy paths ────────────────────────────────────────────────── + + it.skipIf(!hasDistWorker)('dispatch after terminate rejects', async () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 1); + const terminatedPool = pool; + await terminatedPool.terminate(); + pool = undefined; // already terminated — prevent afterEach double-terminate + + await expect(terminatedPool.dispatch([{ path: 'x.ts', content: 'const x = 1;' }])) + .rejects.toThrow(); + }); + + it.skipIf(!hasDistWorker)('double terminate does not throw', async () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 1); + await pool.terminate(); + await expect(pool.terminate()).resolves.toBeUndefined(); + pool = undefined; + }); + + it.skipIf(!hasDistWorker)('dispatches entries with empty content string without crashing', async () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + pool = createWorkerPool(workerUrl, 1); + + const results = await pool.dispatch<any, any>([ + { path: 'empty.ts', content: '' }, + ]); + + expect(results).toHaveLength(1); + const result = results[0]; + expect(typeof result.fileCount).toBe('number'); + expect(result.fileCount).toBeGreaterThanOrEqual(0); + expect(Array.isArray(result.nodes)).toBe(true); + }); + + it.skipIf(!hasDistWorker)('createWorkerPool with size 0 creates pool with zero workers', () => { + const workerUrl = pathToFileURL(DIST_WORKER) as URL; + const zeroPool = createWorkerPool(workerUrl, 0); + expect(zeroPool.size).toBe(0); + return zeroPool.terminate(); + }); +}); diff --git a/gitnexus/test/unit/ai-context.test.ts b/gitnexus/test/unit/ai-context.test.ts new file mode 100644 index 0000000000..6eb47b78fb --- /dev/null +++ b/gitnexus/test/unit/ai-context.test.ts @@ -0,0 +1,80 @@ +import { describe, it, expect, vi, beforeAll, afterAll } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import os from 'os'; +import { generateAIContextFiles } from '../../src/cli/ai-context.js'; + +describe('generateAIContextFiles', () => { + let tmpDir: string; + let storagePath: string; + + beforeAll(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-ai-ctx-test-')); + storagePath = path.join(tmpDir, '.gitnexus'); + await fs.mkdir(storagePath, { recursive: true }); + }); + + afterAll(async () => { + try { + await fs.rm(tmpDir, { recursive: true, force: true }); + } catch { /* best-effort */ } + }); + + it('generates context files', async () => { + const stats = { + nodes: 100, + edges: 200, + processes: 10, + }; + + const result = await generateAIContextFiles(tmpDir, storagePath, 'TestProject', stats); + expect(result.files).toBeDefined(); + expect(result.files.length).toBeGreaterThan(0); + }); + + it('creates or updates CLAUDE.md with GitNexus section', async () => { + const stats = { nodes: 50, edges: 100, processes: 5 }; + await generateAIContextFiles(tmpDir, storagePath, 'TestProject', stats); + + const claudeMdPath = path.join(tmpDir, 'CLAUDE.md'); + const content = await fs.readFile(claudeMdPath, 'utf-8'); + expect(content).toContain('gitnexus:start'); + expect(content).toContain('gitnexus:end'); + expect(content).toContain('TestProject'); + }); + + it('handles empty stats', async () => { + const stats = {}; + const result = await generateAIContextFiles(tmpDir, storagePath, 'EmptyProject', stats); + expect(result.files).toBeDefined(); + }); + + it('updates existing CLAUDE.md without duplicating', async () => { + const stats = { nodes: 10 }; + + // Run twice + await generateAIContextFiles(tmpDir, storagePath, 'TestProject', stats); + await generateAIContextFiles(tmpDir, storagePath, 'TestProject', stats); + + const claudeMdPath = path.join(tmpDir, 'CLAUDE.md'); + const content = await fs.readFile(claudeMdPath, 'utf-8'); + + // Should only have one gitnexus section + const starts = (content.match(/gitnexus:start/g) || []).length; + expect(starts).toBe(1); + }); + + it('installs skills files', async () => { + const stats = { nodes: 10 }; + const result = await generateAIContextFiles(tmpDir, storagePath, 'TestProject', stats); + + // Should have installed skill files + const skillsDir = path.join(tmpDir, '.claude', 'skills', 'gitnexus'); + try { + const entries = await fs.readdir(skillsDir, { recursive: true }); + expect(entries.length).toBeGreaterThan(0); + } catch { + // Skills dir may not be created if skills source doesn't exist in test context + } + }); +}); diff --git a/gitnexus/test/unit/ast-cache.test.ts b/gitnexus/test/unit/ast-cache.test.ts new file mode 100644 index 0000000000..66cc6e3c3f --- /dev/null +++ b/gitnexus/test/unit/ast-cache.test.ts @@ -0,0 +1,95 @@ +import { describe, it, expect, beforeEach } from 'vitest'; +import { createASTCache, type ASTCache } from '../../src/core/ingestion/ast-cache.js'; + +// Create a minimal mock tree object (mimics Parser.Tree interface) +function mockTree(id: string): any { + return { rootNode: { type: 'program', text: id }, delete: vi.fn() }; +} + +describe('ASTCache', () => { + let cache: ASTCache; + + beforeEach(() => { + cache = createASTCache(3); + }); + + describe('get / set', () => { + it('returns undefined for cache miss', () => { + expect(cache.get('nonexistent.ts')).toBeUndefined(); + }); + + it('returns cached tree on hit', () => { + const tree = mockTree('test'); + cache.set('src/index.ts', tree); + expect(cache.get('src/index.ts')).toBe(tree); + }); + + it('overwrites existing entry for same key', () => { + const tree1 = mockTree('v1'); + const tree2 = mockTree('v2'); + cache.set('src/index.ts', tree1); + cache.set('src/index.ts', tree2); + expect(cache.get('src/index.ts')).toBe(tree2); + }); + }); + + describe('LRU eviction', () => { + it('evicts least recently used when capacity exceeded', () => { + cache.set('a.ts', mockTree('a')); + cache.set('b.ts', mockTree('b')); + cache.set('c.ts', mockTree('c')); + // Cache is full (maxSize=3). Adding one more evicts 'a' + cache.set('d.ts', mockTree('d')); + expect(cache.get('a.ts')).toBeUndefined(); + expect(cache.get('b.ts')).toBeDefined(); + expect(cache.get('d.ts')).toBeDefined(); + }); + + it('accessing an entry makes it recently used', () => { + cache.set('a.ts', mockTree('a')); + cache.set('b.ts', mockTree('b')); + cache.set('c.ts', mockTree('c')); + // Touch 'a' to make it recently used + cache.get('a.ts'); + // Now 'b' is LRU + cache.set('d.ts', mockTree('d')); + expect(cache.get('a.ts')).toBeDefined(); + expect(cache.get('b.ts')).toBeUndefined(); + }); + }); + + describe('clear', () => { + it('removes all entries', () => { + cache.set('a.ts', mockTree('a')); + cache.set('b.ts', mockTree('b')); + cache.clear(); + expect(cache.get('a.ts')).toBeUndefined(); + expect(cache.get('b.ts')).toBeUndefined(); + expect(cache.stats().size).toBe(0); + }); + }); + + describe('stats', () => { + it('reports size and maxSize', () => { + expect(cache.stats()).toEqual({ size: 0, maxSize: 3 }); + cache.set('a.ts', mockTree('a')); + expect(cache.stats()).toEqual({ size: 1, maxSize: 3 }); + cache.set('b.ts', mockTree('b')); + expect(cache.stats()).toEqual({ size: 2, maxSize: 3 }); + }); + + it('uses default maxSize of 50', () => { + const defaultCache = createASTCache(); + expect(defaultCache.stats().maxSize).toBe(50); + }); + + it('clamps maxSize of 0 to 1 to prevent LRU cache error', () => { + const zeroCache = createASTCache(0); + expect(zeroCache.stats().maxSize).toBe(1); + // Should still function correctly + const tree = mockTree('test'); + zeroCache.set('a.ts', tree); + expect(zeroCache.get('a.ts')).toBe(tree); + }); + }); +}); diff --git a/gitnexus/test/unit/bm25-search.test.ts b/gitnexus/test/unit/bm25-search.test.ts new file mode 100644 index 0000000000..1d8be757ff --- /dev/null +++ b/gitnexus/test/unit/bm25-search.test.ts @@ -0,0 +1,36 @@ +import { describe, it, expect } from 'vitest'; +import { searchFTSFromLbug, type BM25SearchResult } from '../../src/core/search/bm25-index.js'; + +describe('BM25 search', () => { + describe('searchFTSFromLbug', () => { + it('returns empty array when LadybugDB is not initialized', async () => { + // Without LadybugDB init, search should return empty (not crash) + const results = await searchFTSFromLbug('test query'); + expect(Array.isArray(results)).toBe(true); + expect(results).toHaveLength(0); + }); + + it('handles empty query', async () => { + const results = await searchFTSFromLbug(''); + expect(Array.isArray(results)).toBe(true); + }); + + it('accepts custom limit parameter', async () => { + const results = await searchFTSFromLbug('test', 5); + expect(Array.isArray(results)).toBe(true); + }); + }); + + describe('BM25SearchResult type', () => { + it('has correct shape', () => { + const result: BM25SearchResult = { + filePath: 'src/index.ts', + score: 1.5, + rank: 1, + }; + expect(result.filePath).toBe('src/index.ts'); + expect(result.score).toBe(1.5); + expect(result.rank).toBe(1); + }); + }); +}); diff --git a/gitnexus/test/unit/call-form.test.ts b/gitnexus/test/unit/call-form.test.ts new file mode 100644 index 0000000000..8db43d96f9 --- /dev/null +++ b/gitnexus/test/unit/call-form.test.ts @@ -0,0 +1,456 @@ +import { describe, it, expect } from 'vitest'; +import { inferCallForm, extractReceiverName, type SyntaxNode } from '../../src/core/ingestion/utils.js'; +import { createSymbolTable } from '../../src/core/ingestion/symbol-table.js'; +import Parser from 'tree-sitter'; +import TypeScript from 'tree-sitter-typescript'; +import Python from 'tree-sitter-python'; +import Java from 'tree-sitter-java'; +import CSharp from 'tree-sitter-c-sharp'; +import Kotlin from 'tree-sitter-kotlin'; +import Go from 'tree-sitter-go'; +import Rust from 'tree-sitter-rust'; +import CPP from 'tree-sitter-cpp'; +import PHP from 'tree-sitter-php'; +import { LANGUAGE_QUERIES } from '../../src/core/ingestion/tree-sitter-queries.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; + +/** + * Helper: parse code, run the language query, and return all @call captures + * as { callNode, nameNode } pairs. + */ +function extractCallCaptures( + parser: Parser, + code: string, + language: string, +): Array<{ callNode: SyntaxNode; nameNode: SyntaxNode; calledName: string }> { + const queryStr = LANGUAGE_QUERIES[language]; + if (!queryStr) throw new Error(`No query for ${language}`); + + const tree = parser.parse(code); + const lang = parser.getLanguage(); + const query = new Parser.Query(lang, queryStr); + const matches = query.matches(tree.rootNode); + + const results: Array<{ callNode: SyntaxNode; nameNode: SyntaxNode; calledName: string }> = []; + + for (const match of matches) { + const captureMap: Record<string, SyntaxNode> = {}; + for (const c of match.captures) { + captureMap[c.name] = c.node; + } + if (captureMap['call'] && captureMap['call.name']) { + results.push({ + callNode: captureMap['call'], + nameNode: captureMap['call.name'], + calledName: captureMap['call.name'].text, + }); + } + } + + return results; +} + +describe('inferCallForm', () => { + const parser = new Parser(); + + describe('TypeScript', () => { + it('detects free call', () => { + parser.setLanguage(TypeScript.typescript); + const captures = extractCallCaptures(parser, 'doStuff()', SupportedLanguages.TypeScript); + const match = captures.find(c => c.calledName === 'doStuff'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call', () => { + parser.setLanguage(TypeScript.typescript); + const captures = extractCallCaptures(parser, 'user.save()', SupportedLanguages.TypeScript); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + }); + + describe('Python', () => { + it('detects free call', () => { + parser.setLanguage(Python); + const captures = extractCallCaptures(parser, 'print_result()', SupportedLanguages.Python); + const match = captures.find(c => c.calledName === 'print_result'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call', () => { + parser.setLanguage(Python); + const captures = extractCallCaptures(parser, 'self.save()', SupportedLanguages.Python); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + }); + + describe('Java', () => { + it('detects free call (no object)', () => { + parser.setLanguage(Java); + const code = `class Foo { void run() { doStuff(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Java); + const match = captures.find(c => c.calledName === 'doStuff'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call (with object)', () => { + parser.setLanguage(Java); + const code = `class Foo { void run() { user.save(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Java); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + }); + + describe('C#', () => { + it('detects free call', () => { + parser.setLanguage(CSharp); + const code = `class Foo { void Run() { DoStuff(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.CSharp); + const match = captures.find(c => c.calledName === 'DoStuff'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call', () => { + parser.setLanguage(CSharp); + const code = `class Foo { void Run() { user.Save(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.CSharp); + const match = captures.find(c => c.calledName === 'Save'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + }); + + describe('Go', () => { + it('detects free call', () => { + parser.setLanguage(Go); + const code = `package main\nfunc main() { doStuff() }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Go); + const match = captures.find(c => c.calledName === 'doStuff'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call via selector', () => { + parser.setLanguage(Go); + const code = `package main\nfunc main() { user.Save() }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Go); + const match = captures.find(c => c.calledName === 'Save'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + }); + + describe('Rust', () => { + it('detects free call', () => { + parser.setLanguage(Rust); + const code = `fn main() { do_stuff(); }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Rust); + const match = captures.find(c => c.calledName === 'do_stuff'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call via field_expression', () => { + parser.setLanguage(Rust); + const code = `fn main() { user.save(); }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Rust); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + + it('detects scoped call as free (Foo::new)', () => { + parser.setLanguage(Rust); + const code = `fn main() { Foo::new(); }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Rust); + const match = captures.find(c => c.calledName === 'new'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + }); + + describe('C++', () => { + it('detects free call', () => { + parser.setLanguage(CPP); + const code = `void main() { doStuff(); }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.CPlusPlus); + const match = captures.find(c => c.calledName === 'doStuff'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call via field_expression', () => { + parser.setLanguage(CPP); + const code = `void main() { obj.run(); }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.CPlusPlus); + const match = captures.find(c => c.calledName === 'run'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + }); + + describe('PHP', () => { + it('detects free function call', () => { + parser.setLanguage(PHP.php); + const code = `<?php doStuff(); ?>`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.PHP); + const match = captures.find(c => c.calledName === 'doStuff'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call', () => { + parser.setLanguage(PHP.php); + const code = `<?php $user->save(); ?>`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.PHP); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + + it('detects static call as member', () => { + parser.setLanguage(PHP.php); + const code = `<?php Foo::bar(); ?>`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.PHP); + const match = captures.find(c => c.calledName === 'bar'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + }); + + describe('Kotlin', () => { + it('detects free call', () => { + parser.setLanguage(Kotlin); + const code = `fun main() { doStuff() }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Kotlin); + const match = captures.find(c => c.calledName === 'doStuff'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects member call via navigation_expression', () => { + parser.setLanguage(Kotlin); + const code = `fun main() { user.save() }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Kotlin); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + }); + + it('Foo() is a free call (constructor_invocation only in heritage context)', () => { + parser.setLanguage(Kotlin); + const code = `fun main() { val x = Foo() }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Kotlin); + const match = captures.find(c => c.calledName === 'Foo'); + expect(match).toBeDefined(); + // Kotlin Foo() is syntactically a call_expression, not constructor_invocation + // Constructor discrimination happens in Phase 2 via symbol kind matching + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('free'); + }); + + it('detects constructor_invocation in heritage delegation as constructor', () => { + parser.setLanguage(Kotlin); + const code = `open class Base\nclass Derived : Base()`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Kotlin); + const match = captures.find(c => c.calledName === 'Base'); + // constructor_invocation is captured by heritage queries, not call queries + // If it happens to be captured, it should be 'constructor' + if (match) { + expect(inferCallForm(match.callNode, match.nameNode)).toBe('constructor'); + } + }); + }); +}); + +describe('extractReceiverName', () => { + const parser = new Parser(); + + describe('TypeScript', () => { + it('extracts simple identifier receiver', () => { + parser.setLanguage(TypeScript.typescript); + const captures = extractCallCaptures(parser, 'user.save()', SupportedLanguages.TypeScript); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + + it('extracts "this" as receiver', () => { + parser.setLanguage(TypeScript.typescript); + const code = `class Foo { run() { this.save(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.TypeScript); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('this'); + }); + + it('returns undefined for chained call receiver', () => { + parser.setLanguage(TypeScript.typescript); + const captures = extractCallCaptures(parser, 'getUser().save()', SupportedLanguages.TypeScript); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBeUndefined(); + }); + + it('returns undefined for free call', () => { + parser.setLanguage(TypeScript.typescript); + const captures = extractCallCaptures(parser, 'doStuff()', SupportedLanguages.TypeScript); + const match = captures.find(c => c.calledName === 'doStuff'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBeUndefined(); + }); + + it('extracts receiver from optional chain call user?.save()', () => { + parser.setLanguage(TypeScript.typescript); + const captures = extractCallCaptures(parser, 'user?.save()', SupportedLanguages.TypeScript); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + + it('extracts "this" from optional chain call this?.save()', () => { + parser.setLanguage(TypeScript.typescript); + const code = `class Foo { run() { this?.save(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.TypeScript); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('this'); + }); + }); + + describe('Python', () => { + it('extracts simple identifier receiver', () => { + parser.setLanguage(Python); + const captures = extractCallCaptures(parser, 'user.save()', SupportedLanguages.Python); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + + it('extracts "self" as receiver', () => { + parser.setLanguage(Python); + const captures = extractCallCaptures(parser, 'self.save()', SupportedLanguages.Python); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('self'); + }); + }); + + describe('Java', () => { + it('extracts receiver from method_invocation', () => { + parser.setLanguage(Java); + const code = `class Foo { void run() { user.save(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Java); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + }); + + describe('Go', () => { + it('extracts receiver from selector_expression', () => { + parser.setLanguage(Go); + const code = `package main\nfunc main() { user.Save() }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Go); + const match = captures.find(c => c.calledName === 'Save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + }); + + describe('Rust', () => { + it('extracts receiver from field_expression', () => { + parser.setLanguage(Rust); + const code = `fn main() { user.save(); }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Rust); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + }); + + describe('C#', () => { + it('extracts receiver from member_access_expression', () => { + parser.setLanguage(CSharp); + const code = `class Foo { void Run() { user.Save(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.CSharp); + const match = captures.find(c => c.calledName === 'Save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + + it('captures null-conditional user?.Save() and extracts receiver', () => { + parser.setLanguage(CSharp); + const code = `class Foo { void Run() { user?.Save(); } }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.CSharp); + const match = captures.find(c => c.calledName === 'Save'); + // C# conditional_access_expression (user?.Save()) is now captured via member_binding_expression + expect(match).toBeDefined(); + expect(inferCallForm(match!.callNode, match!.nameNode)).toBe('member'); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + }); + + describe('Kotlin', () => { + it('extracts receiver from navigation_expression', () => { + parser.setLanguage(Kotlin); + const code = `fun main() { user.save() }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Kotlin); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + + it('extracts receiver from safe navigation user?.save()', () => { + parser.setLanguage(Kotlin); + const code = `fun main() { user?.save() }`; + const captures = extractCallCaptures(parser, code, SupportedLanguages.Kotlin); + const match = captures.find(c => c.calledName === 'save'); + expect(match).toBeDefined(); + expect(extractReceiverName(match!.nameNode)).toBe('user'); + }); + }); +}); + +describe('ownerId on SymbolDefinition', () => { + it('is set for Method symbols via symbolTable.add()', () => { + const st = createSymbolTable(); + st.add('src/foo.ts', 'save', 'Method:src/foo.ts:save', 'Method', { + parameterCount: 1, + ownerId: 'Class:src/foo.ts:User', + }); + + const def = st.lookupExactFull('src/foo.ts', 'save'); + expect(def).toBeDefined(); + expect(def!.ownerId).toBe('Class:src/foo.ts:User'); + expect(def!.parameterCount).toBe(1); + }); + + it('is undefined for Function symbols (no owner)', () => { + const st = createSymbolTable(); + st.add('src/foo.ts', 'helper', 'Function:src/foo.ts:helper', 'Function'); + + const def = st.lookupExactFull('src/foo.ts', 'helper'); + expect(def).toBeDefined(); + expect(def!.ownerId).toBeUndefined(); + }); + + it('propagates ownerId through lookupFuzzy', () => { + const st = createSymbolTable(); + st.add('src/foo.ts', 'save', 'Method:src/foo.ts:save', 'Method', { + ownerId: 'Class:src/foo.ts:User', + }); + + const defs = st.lookupFuzzy('save'); + expect(defs).toHaveLength(1); + expect(defs[0].ownerId).toBe('Class:src/foo.ts:User'); + }); +}); diff --git a/gitnexus/test/unit/call-processor.test.ts b/gitnexus/test/unit/call-processor.test.ts new file mode 100644 index 0000000000..429bdd0d2a --- /dev/null +++ b/gitnexus/test/unit/call-processor.test.ts @@ -0,0 +1,870 @@ +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { processCallsFromExtracted } from '../../src/core/ingestion/call-processor.js'; +import { extractReturnTypeName } from '../../src/core/ingestion/type-extractors/shared.js'; +import { createResolutionContext, type ResolutionContext } from '../../src/core/ingestion/resolution-context.js'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import type { ExtractedCall, FileConstructorBindings } from '../../src/core/ingestion/workers/parse-worker.js'; + +describe('processCallsFromExtracted', () => { + let graph: ReturnType<typeof createKnowledgeGraph>; + let ctx: ResolutionContext; + + beforeEach(() => { + graph = createKnowledgeGraph(); + ctx = createResolutionContext(); + }); + + it('creates CALLS relationship for same-file resolution', async () => { + ctx.symbols.add('src/index.ts', 'helper', 'Function:src/index.ts:helper', 'Function'); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'helper', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].sourceId).toBe('Function:src/index.ts:main'); + expect(rels[0].targetId).toBe('Function:src/index.ts:helper'); + expect(rels[0].confidence).toBe(0.95); + expect(rels[0].reason).toBe('same-file'); + }); + + it('creates CALLS relationship for import-resolved resolution', async () => { + ctx.symbols.add('src/utils.ts', 'format', 'Function:src/utils.ts:format', 'Function'); + ctx.importMap.set('src/index.ts', new Set(['src/utils.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'format', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].confidence).toBe(0.9); + expect(rels[0].reason).toBe('import-resolved'); + }); + + it('resolves unique global symbol with moderate confidence', async () => { + ctx.symbols.add('src/other.ts', 'uniqueFunc', 'Function:src/other.ts:uniqueFunc', 'Function'); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'uniqueFunc', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].confidence).toBe(0.5); + expect(rels[0].reason).toBe('global'); + }); + + it('refuses ambiguous global symbols — no CALLS edge created', async () => { + ctx.symbols.add('src/a.ts', 'render', 'Function:src/a.ts:render', 'Function'); + ctx.symbols.add('src/b.ts', 'render', 'Function:src/b.ts:render', 'Function'); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'render', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(0); + }); + + it('skips unresolvable calls', async () => { + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'nonExistent', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + expect(graph.relationshipCount).toBe(0); + }); + + it('refuses non-callable symbols even when the name resolves', async () => { + ctx.symbols.add('src/index.ts', 'Widget', 'Class:src/index.ts:Widget', 'Class'); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'Widget', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + expect(graph.relationshipCount).toBe(0); + }); + + it('refuses CALLS edges to Interface symbols', async () => { + ctx.symbols.add('src/types.ts', 'Serializable', 'Interface:src/types.ts:Serializable', 'Interface'); + ctx.importMap.set('src/index.ts', new Set(['src/types.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'Serializable', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + expect(graph.relationships.filter(r => r.type === 'CALLS')).toHaveLength(0); + }); + + it('refuses CALLS edges to Enum symbols', async () => { + ctx.symbols.add('src/status.ts', 'Status', 'Enum:src/status.ts:Status', 'Enum'); + ctx.importMap.set('src/index.ts', new Set(['src/status.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'Status', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + expect(graph.relationships.filter(r => r.type === 'CALLS')).toHaveLength(0); + }); + + it('prefers same-file over import-resolved', async () => { + ctx.symbols.add('src/index.ts', 'render', 'Function:src/index.ts:render', 'Function'); + ctx.symbols.add('src/utils.ts', 'render', 'Function:src/utils.ts:render', 'Function'); + ctx.importMap.set('src/index.ts', new Set(['src/utils.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'render', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Function:src/index.ts:render'); + expect(rels[0].reason).toBe('same-file'); + }); + + it('handles multiple calls from the same file', async () => { + ctx.symbols.add('src/index.ts', 'foo', 'Function:src/index.ts:foo', 'Function'); + ctx.symbols.add('src/index.ts', 'bar', 'Function:src/index.ts:bar', 'Function'); + + const calls: ExtractedCall[] = [ + { filePath: 'src/index.ts', calledName: 'foo', sourceId: 'Function:src/index.ts:main' }, + { filePath: 'src/index.ts', calledName: 'bar', sourceId: 'Function:src/index.ts:main' }, + ]; + + await processCallsFromExtracted(graph, calls, ctx); + expect(graph.relationships.filter(r => r.type === 'CALLS')).toHaveLength(2); + }); + + it('uses arity to disambiguate import-scoped callable candidates', async () => { + ctx.symbols.add('src/logger.ts', 'log', 'Function:src/logger.ts:log', 'Function', { parameterCount: 0 }); + ctx.symbols.add('src/formatter.ts', 'log', 'Function:src/formatter.ts:log', 'Function', { parameterCount: 1 }); + ctx.importMap.set('src/index.ts', new Set(['src/logger.ts', 'src/formatter.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'log', + sourceId: 'Function:src/index.ts:main', + argCount: 1, + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Function:src/formatter.ts:log'); + expect(rels[0].reason).toBe('import-resolved'); + }); + + it('refuses ambiguous call targets when arity does not produce a unique match', async () => { + ctx.symbols.add('src/logger.ts', 'log', 'Function:src/logger.ts:log', 'Function', { parameterCount: 1 }); + ctx.symbols.add('src/formatter.ts', 'log', 'Function:src/formatter.ts:log', 'Function', { parameterCount: 1 }); + ctx.importMap.set('src/index.ts', new Set(['src/logger.ts', 'src/formatter.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'log', + sourceId: 'Function:src/index.ts:main', + argCount: 1, + }]; + + await processCallsFromExtracted(graph, calls, ctx); + expect(graph.relationships.filter(r => r.type === 'CALLS')).toHaveLength(0); + }); + + it('calls progress callback', async () => { + ctx.symbols.add('src/index.ts', 'foo', 'Function:src/index.ts:foo', 'Function'); + + const calls: ExtractedCall[] = [ + { filePath: 'src/index.ts', calledName: 'foo', sourceId: 'Function:src/index.ts:main' }, + ]; + + const onProgress = vi.fn(); + await processCallsFromExtracted(graph, calls, ctx, onProgress); + + expect(onProgress).toHaveBeenCalledWith(1, 1); + }); + + it('handles empty calls array', async () => { + await processCallsFromExtracted(graph, [], ctx); + expect(graph.relationshipCount).toBe(0); + }); + + // ---- Constructor-aware resolution (Phase 2) ---- + + it('resolves constructor call to Class when no Constructor node exists', async () => { + ctx.symbols.add('src/models.ts', 'User', 'Class:src/models.ts:User', 'Class'); + ctx.importMap.set('src/index.ts', new Set(['src/models.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'User', + sourceId: 'Function:src/index.ts:main', + callForm: 'constructor', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Class:src/models.ts:User'); + expect(rels[0].reason).toBe('import-resolved'); + }); + + it('resolves constructor call to Constructor node over Class node', async () => { + ctx.symbols.add('src/models.ts', 'User', 'Class:src/models.ts:User', 'Class'); + ctx.symbols.add('src/models.ts', 'User', 'Constructor:src/models.ts:User', 'Constructor', { parameterCount: 1 }); + ctx.importMap.set('src/index.ts', new Set(['src/models.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'User', + sourceId: 'Function:src/index.ts:main', + argCount: 1, + callForm: 'constructor', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Constructor:src/models.ts:User'); + }); + + it('refuses Class target without callForm=constructor (existing behavior)', async () => { + ctx.symbols.add('src/models.ts', 'User', 'Class:src/models.ts:User', 'Class'); + ctx.importMap.set('src/index.ts', new Set(['src/models.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'User', + sourceId: 'Function:src/index.ts:main', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(0); + }); + + it('constructor call falls back to callable types when no Constructor/Class found', async () => { + ctx.symbols.add('src/utils.ts', 'Widget', 'Function:src/utils.ts:Widget', 'Function'); + ctx.importMap.set('src/index.ts', new Set(['src/utils.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'Widget', + sourceId: 'Function:src/index.ts:main', + callForm: 'constructor', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Function:src/utils.ts:Widget'); + }); + + it('constructor arity filtering narrows overloaded constructors', async () => { + ctx.symbols.add('src/models.ts', 'User', 'Constructor:src/models.ts:User(0)', 'Constructor', { parameterCount: 0 }); + ctx.symbols.add('src/models.ts', 'User', 'Constructor:src/models.ts:User(2)', 'Constructor', { parameterCount: 2 }); + ctx.importMap.set('src/index.ts', new Set(['src/models.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'User', + sourceId: 'Function:src/index.ts:main', + argCount: 2, + callForm: 'constructor', + }]; + + await processCallsFromExtracted(graph, calls, ctx); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Constructor:src/models.ts:User(2)'); + }); + + it('cannot discriminate same-arity overloads by parameter type (known limitation)', async () => { + ctx.symbols.add('src/UserDao.ts', 'save', 'Function:src/UserDao.ts:save', 'Function', { parameterCount: 1 }); + ctx.symbols.add('src/RepoDao.ts', 'save', 'Function:src/RepoDao.ts:save', 'Function', { parameterCount: 1 }); + ctx.importMap.set('src/index.ts', new Set(['src/UserDao.ts', 'src/RepoDao.ts'])); + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'save', + sourceId: 'Function:src/index.ts:main', + argCount: 1, + }]; + + await processCallsFromExtracted(graph, calls, ctx); + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(0); + }); + + // ---- Return type inference (Phase 4) ---- + + it('return type inference: binds variable to return type of callee', async () => { + // getUser() returns User, and User has a save() method + ctx.symbols.add('src/utils.ts', 'getUser', 'Function:src/utils.ts:getUser', 'Function', { returnType: 'User' }); + ctx.symbols.add('src/models.ts', 'User', 'Class:src/models.ts:User', 'Class'); + ctx.symbols.add('src/models.ts', 'save', 'Method:src/models.ts:save', 'Method', { ownerId: 'Class:src/models.ts:User' }); + ctx.importMap.set('src/index.ts', new Set(['src/utils.ts', 'src/models.ts'])); + + // Binding: user = getUser() — getUser is not a class, so constructor path fails, + // but return type inference should kick in + const constructorBindings: FileConstructorBindings[] = [{ + filePath: 'src/index.ts', + bindings: [ + { scope: 'main@0', varName: 'user', calleeName: 'getUser' }, + ], + }]; + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'save', + sourceId: 'Function:src/index.ts:main', + receiverName: 'user', + callForm: 'member', + }]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Method:src/models.ts:save'); + }); + + it('return type inference: unwraps Promise<User> to User', async () => { + ctx.symbols.add('src/api.ts', 'fetchUser', 'Function:src/api.ts:fetchUser', 'Function', { returnType: 'Promise<User>' }); + ctx.symbols.add('src/models.ts', 'User', 'Class:src/models.ts:User', 'Class'); + ctx.symbols.add('src/models.ts', 'save', 'Method:src/models.ts:save', 'Method', { ownerId: 'Class:src/models.ts:User' }); + ctx.importMap.set('src/index.ts', new Set(['src/api.ts', 'src/models.ts'])); + + const constructorBindings: FileConstructorBindings[] = [{ + filePath: 'src/index.ts', + bindings: [ + { scope: 'main@0', varName: 'user', calleeName: 'fetchUser' }, + ], + }]; + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'save', + sourceId: 'Function:src/index.ts:main', + receiverName: 'user', + callForm: 'member', + }]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Method:src/models.ts:save'); + }); + + it('return type inference: skips when return type is primitive', async () => { + ctx.symbols.add('src/utils.ts', 'getCount', 'Function:src/utils.ts:getCount', 'Function', { returnType: 'number' }); + ctx.importMap.set('src/index.ts', new Set(['src/utils.ts'])); + + const constructorBindings: FileConstructorBindings[] = [{ + filePath: 'src/index.ts', + bindings: [ + { scope: 'main@0', varName: 'count', calleeName: 'getCount' }, + ], + }]; + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'toString', + sourceId: 'Function:src/index.ts:main', + receiverName: 'count', + callForm: 'member', + }]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + // No binding should be created for primitive return types + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(0); + }); + + it('return type inference: skips ambiguous callees (multiple definitions)', async () => { + ctx.symbols.add('src/a.ts', 'getData', 'Function:src/a.ts:getData', 'Function', { returnType: 'User' }); + ctx.symbols.add('src/b.ts', 'getData', 'Function:src/b.ts:getData', 'Function', { returnType: 'Repo' }); + + const constructorBindings: FileConstructorBindings[] = [{ + filePath: 'src/index.ts', + bindings: [ + { scope: 'main@0', varName: 'data', calleeName: 'getData' }, + ], + }]; + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'save', + sourceId: 'Function:src/index.ts:main', + receiverName: 'data', + callForm: 'member', + }]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + // Ambiguous callee — don't guess + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(0); + }); + + it('return type inference: prefers constructor binding over return type', async () => { + // If the callee IS a class, constructor binding wins (existing behavior) + ctx.symbols.add('src/models.ts', 'User', 'Class:src/models.ts:User', 'Class'); + ctx.symbols.add('src/models.ts', 'save', 'Method:src/models.ts:save', 'Method', { ownerId: 'Class:src/models.ts:User' }); + ctx.importMap.set('src/index.ts', new Set(['src/models.ts'])); + + const constructorBindings: FileConstructorBindings[] = [{ + filePath: 'src/index.ts', + bindings: [ + { scope: 'main@0', varName: 'user', calleeName: 'User' }, + ], + }]; + + const calls: ExtractedCall[] = [{ + filePath: 'src/index.ts', + calledName: 'save', + sourceId: 'Function:src/index.ts:main', + receiverName: 'user', + callForm: 'member', + }]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Method:src/models.ts:save'); + }); + + // ---- Scope-aware constructor bindings (Phase 3) ---- + + it('receiverKey collision: same method name in different classes does not collide', async () => { + // User.save@100 and Repo.save@200 are two methods named "save" in different classes. + // Each has a local variable "db" pointing to a different type. + // Without @startIndex in the key, the second binding would overwrite the first. + ctx.symbols.add('src/db/Database.ts', 'Database', 'Class:src/db/Database.ts:Database', 'Class'); + ctx.symbols.add('src/db/Cache.ts', 'Cache', 'Class:src/db/Cache.ts:Cache', 'Class'); + ctx.symbols.add('src/db/Database.ts', 'query', 'Method:src/db/Database.ts:query', 'Method', { ownerId: 'Class:src/db/Database.ts:Database' }); + ctx.symbols.add('src/db/Cache.ts', 'query', 'Method:src/db/Cache.ts:query', 'Method', { ownerId: 'Class:src/db/Cache.ts:Cache' }); + ctx.importMap.set('src/models/User.ts', new Set(['src/db/Database.ts'])); + ctx.importMap.set('src/models/Repo.ts', new Set(['src/db/Cache.ts'])); + + // Two bindings: both enclosing scope is named "save" but at different startIndexes + const constructorBindings: FileConstructorBindings[] = [ + { + filePath: 'src/models/User.ts', + bindings: [ + // save@100: inside User.save(), db = new Database() + { scope: 'save@100', varName: 'db', calleeName: 'Database' }, + ], + }, + { + filePath: 'src/models/Repo.ts', + bindings: [ + // save@200: inside Repo.save(), db = new Cache() + { scope: 'save@200', varName: 'db', calleeName: 'Cache' }, + ], + }, + ]; + + const calls: ExtractedCall[] = [ + { + filePath: 'src/models/User.ts', + calledName: 'query', + sourceId: 'Method:src/models/User.ts:save', + receiverName: 'db', + callForm: 'member', + }, + { + filePath: 'src/models/Repo.ts', + calledName: 'query', + sourceId: 'Method:src/models/Repo.ts:save', + receiverName: 'db', + callForm: 'member', + }, + ]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(2); + const userQueryRel = rels.find(r => r.sourceId === 'Method:src/models/User.ts:save'); + const repoQueryRel = rels.find(r => r.sourceId === 'Method:src/models/Repo.ts:save'); + expect(userQueryRel?.targetId).toBe('Method:src/db/Database.ts:query'); + expect(repoQueryRel?.targetId).toBe('Method:src/db/Cache.ts:query'); + }); + + it('receiverKey collision: same scope funcName + same varName + same type resolves (non-ambiguous)', async () => { + // Two save@* scopes both bind "db" to the same type — not ambiguous, should resolve. + ctx.symbols.add('src/db/Database.ts', 'Database', 'Class:src/db/Database.ts:Database', 'Class'); + ctx.symbols.add('src/db/Database.ts', 'query', 'Method:src/db/Database.ts:query', 'Method', { ownerId: 'Class:src/db/Database.ts:Database' }); + ctx.importMap.set('src/service.ts', new Set(['src/db/Database.ts'])); + + const constructorBindings: FileConstructorBindings[] = [{ + filePath: 'src/service.ts', + bindings: [ + { scope: 'save@10', varName: 'db', calleeName: 'Database' }, + { scope: 'save@50', varName: 'db', calleeName: 'Database' }, + ], + }]; + + const calls: ExtractedCall[] = [{ + filePath: 'src/service.ts', + calledName: 'query', + sourceId: 'Method:src/service.ts:save', + receiverName: 'db', + callForm: 'member', + }]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(1); + expect(rels[0].targetId).toBe('Method:src/db/Database.ts:query'); + }); + + it('receiverKey collision: same scope funcName + same varName + different types → ambiguous, no CALLS edge', async () => { + // Two save@* scopes in the same file bind "db" to different types — truly ambiguous. + ctx.symbols.add('src/db/Database.ts', 'Database', 'Class:src/db/Database.ts:Database', 'Class'); + ctx.symbols.add('src/db/Cache.ts', 'Cache', 'Class:src/db/Cache.ts:Cache', 'Class'); + ctx.symbols.add('src/db/Database.ts', 'query', 'Method:src/db/Database.ts:query', 'Method', { ownerId: 'Class:src/db/Database.ts:Database' }); + ctx.symbols.add('src/db/Cache.ts', 'query', 'Method:src/db/Cache.ts:query', 'Method', { ownerId: 'Class:src/db/Cache.ts:Cache' }); + ctx.importMap.set('src/service.ts', new Set(['src/db/Database.ts', 'src/db/Cache.ts'])); + + const constructorBindings: FileConstructorBindings[] = [{ + filePath: 'src/service.ts', + bindings: [ + { scope: 'save@10', varName: 'db', calleeName: 'Database' }, + { scope: 'save@50', varName: 'db', calleeName: 'Cache' }, + ], + }]; + + const calls: ExtractedCall[] = [{ + filePath: 'src/service.ts', + calledName: 'query', + sourceId: 'Method:src/service.ts:save', + receiverName: 'db', + callForm: 'member', + }]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + // Ambiguous — different types for same funcName+varName, should not emit a CALLS edge + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(0); + }); + + it('scope-aware bindings: same varName in different functions resolves to correct type', async () => { + ctx.symbols.add('src/models.ts', 'User', 'Class:src/models.ts:User', 'Class'); + ctx.symbols.add('src/models.ts', 'Repo', 'Class:src/models.ts:Repo', 'Class'); + ctx.symbols.add('src/models.ts', 'save', 'Function:src/models.ts:save', 'Function'); + ctx.importMap.set('src/index.ts', new Set(['src/models.ts'])); + + const constructorBindings: FileConstructorBindings[] = [{ + filePath: 'src/index.ts', + bindings: [ + { scope: 'processUser@12', varName: 'obj', calleeName: 'User' }, + { scope: 'processRepo@89', varName: 'obj', calleeName: 'Repo' }, + ], + }]; + + const calls: ExtractedCall[] = [ + { + filePath: 'src/index.ts', + calledName: 'save', + sourceId: 'Function:src/index.ts:processUser', + receiverName: 'obj', + callForm: 'member', + }, + { + filePath: 'src/index.ts', + calledName: 'save', + sourceId: 'Function:src/index.ts:processRepo', + receiverName: 'obj', + callForm: 'member', + }, + ]; + + await processCallsFromExtracted(graph, calls, ctx, undefined, constructorBindings); + + const rels = graph.relationships.filter(r => r.type === 'CALLS'); + expect(rels).toHaveLength(2); + // Both calls should resolve, each with the correct receiver type from their scope + // (the important thing is they don't collide — without scope awareness, + // last-write-wins would give both calls the same receiver type) + expect(rels[0].sourceId).toBe('Function:src/index.ts:processUser'); + expect(rels[1].sourceId).toBe('Function:src/index.ts:processRepo'); + }); +}); + +describe('extractReturnTypeName', () => { + it('extracts simple type name', () => { + expect(extractReturnTypeName('User')).toBe('User'); + }); + + it('unwraps Promise<User>', () => { + expect(extractReturnTypeName('Promise<User>')).toBe('User'); + }); + + it('unwraps Option<User>', () => { + expect(extractReturnTypeName('Option<User>')).toBe('User'); + }); + + it('unwraps Result<User, Error> to first type arg', () => { + expect(extractReturnTypeName('Result<User, Error>')).toBe('User'); + }); + + it('strips nullable union: User | null', () => { + expect(extractReturnTypeName('User | null')).toBe('User'); + }); + + it('strips nullable union: User | undefined', () => { + expect(extractReturnTypeName('User | undefined')).toBe('User'); + }); + + it('strips nullable suffix: User?', () => { + expect(extractReturnTypeName('User?')).toBe('User'); + }); + + it('strips Go pointer: *User', () => { + expect(extractReturnTypeName('*User')).toBe('User'); + }); + + it('strips Rust reference: &User', () => { + expect(extractReturnTypeName('&User')).toBe('User'); + }); + + it('strips Rust mutable reference: &mut User', () => { + expect(extractReturnTypeName('&mut User')).toBe('User'); + }); + + it('returns undefined for primitives', () => { + expect(extractReturnTypeName('string')).toBeUndefined(); + expect(extractReturnTypeName('number')).toBeUndefined(); + expect(extractReturnTypeName('boolean')).toBeUndefined(); + expect(extractReturnTypeName('void')).toBeUndefined(); + expect(extractReturnTypeName('int')).toBeUndefined(); + }); + + it('returns undefined for genuine union types', () => { + expect(extractReturnTypeName('User | Repo')).toBeUndefined(); + }); + + it('returns undefined for empty string', () => { + expect(extractReturnTypeName('')).toBeUndefined(); + }); + + it('extracts qualified type: models.User → User', () => { + expect(extractReturnTypeName('models.User')).toBe('User'); + }); + + it('handles non-wrapper generics: Map<K, V> → Map', () => { + expect(extractReturnTypeName('Map<string, User>')).toBe('Map'); + }); + + it('handles nested wrapper: Promise<Option<User>>', () => { + // Promise<Option<User>> → unwrap Promise → Option<User> → unwrap Option → User + expect(extractReturnTypeName('Promise<Option<User>>')).toBe('User'); + }); + + it('returns base type for collection generics (not unwrapped)', () => { + expect(extractReturnTypeName('Vec<User>')).toBe('Vec'); + expect(extractReturnTypeName('List<User>')).toBe('List'); + expect(extractReturnTypeName('Array<User>')).toBe('Array'); + expect(extractReturnTypeName('Set<User>')).toBe('Set'); + expect(extractReturnTypeName('ArrayList<User>')).toBe('ArrayList'); + }); + + it('unwraps Optional<User>', () => { + expect(extractReturnTypeName('Optional<User>')).toBe('User'); + }); + + it('extracts Ruby :: qualified type: Models::User → User', () => { + expect(extractReturnTypeName('Models::User')).toBe('User'); + }); + + it('extracts C++ :: qualified type: ns::HttpClient → HttpClient', () => { + expect(extractReturnTypeName('ns::HttpClient')).toBe('HttpClient'); + }); + + it('extracts deep :: qualified type: crate::models::User → User', () => { + expect(extractReturnTypeName('crate::models::User')).toBe('User'); + }); + + it('extracts mixed qualifier: ns.module::User → User', () => { + expect(extractReturnTypeName('ns.module::User')).toBe('User'); + }); + + it('returns undefined for lowercase :: qualified: std::vector', () => { + expect(extractReturnTypeName('std::vector')).toBeUndefined(); + }); + + it('extracts deep dot-qualified: com.example.models.User → User', () => { + expect(extractReturnTypeName('com.example.models.User')).toBe('User'); + }); + + it('unwraps wrapper over non-wrapper generic: Promise<Map<string, User>> → Map', () => { + // Promise is a wrapper — unwrap it to get Map<string, User>. + // Map is not a wrapper, so return its base type: Map. + expect(extractReturnTypeName('Promise<Map<string, User>>')).toBe('Map'); + }); + + it('unwraps doubly-nested wrapper: Future<Result<User, Error>> → User', () => { + // Future → unwrap → Result<User, Error>; Result → unwrap first arg → User + expect(extractReturnTypeName('Future<Result<User, Error>>')).toBe('User'); + }); + + it('unwraps CompletableFuture<Optional<User>> → User', () => { + // CompletableFuture → unwrap → Optional<User>; Optional → unwrap → User + expect(extractReturnTypeName('CompletableFuture<Optional<User>>')).toBe('User'); + }); + + // Rust smart pointer unwrapping + it('unwraps Rc<User> → User', () => { + expect(extractReturnTypeName('Rc<User>')).toBe('User'); + }); + it('unwraps Arc<User> → User', () => { + expect(extractReturnTypeName('Arc<User>')).toBe('User'); + }); + it('unwraps Weak<User> → User', () => { + expect(extractReturnTypeName('Weak<User>')).toBe('User'); + }); + it('unwraps MutexGuard<User> → User', () => { + expect(extractReturnTypeName('MutexGuard<User>')).toBe('User'); + }); + it('unwraps RwLockReadGuard<User> → User', () => { + expect(extractReturnTypeName('RwLockReadGuard<User>')).toBe('User'); + }); + it('unwraps Cow<User> → User', () => { + expect(extractReturnTypeName('Cow<User>')).toBe('User'); + }); + // Nested: Arc<Option<User>> → User (double unwrap) + it('unwraps Arc<Option<User>> → User', () => { + expect(extractReturnTypeName('Arc<Option<User>>')).toBe('User'); + }); + // NOT unwrapped (containers/wrappers not in set) + it('does not unwrap Mutex<User> (not a Deref wrapper)', () => { + expect(extractReturnTypeName('Mutex<User>')).toBe('Mutex'); + }); + + // Rust lifetime parameters in wrapper generics + it("skips lifetime in Ref<'_, User> → User", () => { + expect(extractReturnTypeName("Ref<'_, User>")).toBe('User'); + }); + it("skips lifetime in RefMut<'a, User> → User", () => { + expect(extractReturnTypeName("RefMut<'a, User>")).toBe('User'); + }); + it("skips lifetime in MutexGuard<'_, User> → User", () => { + expect(extractReturnTypeName("MutexGuard<'_, User>")).toBe('User'); + }); + + it('returns undefined for lowercase non-class types', () => { + expect(extractReturnTypeName('error')).toBeUndefined(); + }); + + it('extracts PHP backslash-namespaced type: \\App\\Models\\User → User', () => { + expect(extractReturnTypeName('\\App\\Models\\User')).toBe('User'); + }); + + it('extracts PHP single-segment namespace: \\User → User', () => { + expect(extractReturnTypeName('\\User')).toBe('User'); + }); + + it('extracts PHP deep namespace: \\Vendor\\Package\\Sub\\Client → Client', () => { + expect(extractReturnTypeName('\\Vendor\\Package\\Sub\\Client')).toBe('Client'); + }); + + it('returns undefined for bare wrapper type names without generic arguments', () => { + expect(extractReturnTypeName('Task')).toBeUndefined(); + expect(extractReturnTypeName('Promise')).toBeUndefined(); + expect(extractReturnTypeName('Future')).toBeUndefined(); + expect(extractReturnTypeName('Option')).toBeUndefined(); + expect(extractReturnTypeName('Result')).toBeUndefined(); + expect(extractReturnTypeName('Observable')).toBeUndefined(); + expect(extractReturnTypeName('ValueTask')).toBeUndefined(); + expect(extractReturnTypeName('CompletableFuture')).toBeUndefined(); + expect(extractReturnTypeName('Optional')).toBeUndefined(); + }); + + // ---- Length caps (Phase 6) ---- + + it('pre-cap: returns undefined when raw input exceeds 2048 characters', () => { + const longInput = 'A'.repeat(2049); + expect(extractReturnTypeName(longInput)).toBeUndefined(); + }); + + it('pre-cap: accepts raw input at exactly 2048 characters (boundary)', () => { + // A 2048-char string of uppercase letters passes the pre-cap gate. + // It won't match as a valid identifier (too long for post-cap), so the + // result is undefined — but the pre-cap itself does NOT reject it. + // We test this by verifying a 2048-char type that WOULD be valid in all + // other respects is still returned as undefined (post-cap rejects it). + const atLimit = 'U' + 'x'.repeat(2047); // 2048 chars, starts with uppercase + // Post-cap (512) will reject this, but the pre-cap should not fire. + // The important assertion: no throw and the result is undefined from post-cap. + expect(extractReturnTypeName(atLimit)).toBeUndefined(); + }); + + it('pre-cap: accepts inputs shorter than 2048 characters without rejection', () => { + // 'User' is well under 2048 — should resolve normally. + expect(extractReturnTypeName('User')).toBe('User'); + }); + + it('post-cap: returns undefined when extracted type name exceeds 512 characters', () => { + // Construct a raw string that is under the 2048-char pre-cap but produces + // a final identifier longer than 512 characters after extraction. + // A bare uppercase identifier of 513 chars satisfies all rules except post-cap. + const longTypeName = 'U' + 'x'.repeat(512); // 513 chars, starts with uppercase + expect(extractReturnTypeName(longTypeName)).toBeUndefined(); + }); + + it('post-cap: accepts extracted type name at exactly 512 characters (boundary)', () => { + // 512-char identifier should pass the post-cap check (> 512 rejects, not >=). + const atLimit = 'U' + 'x'.repeat(511); // exactly 512 chars + expect(extractReturnTypeName(atLimit)).toBe(atLimit); + }); + + it('post-cap: accepts normal short type names well under 512 characters', () => { + expect(extractReturnTypeName('HttpClient')).toBe('HttpClient'); + expect(extractReturnTypeName('UserService')).toBe('UserService'); + }); +}); diff --git a/gitnexus/test/unit/call-routing.test.ts b/gitnexus/test/unit/call-routing.test.ts new file mode 100644 index 0000000000..d1efb9ddea --- /dev/null +++ b/gitnexus/test/unit/call-routing.test.ts @@ -0,0 +1,694 @@ +import { describe, it, expect } from 'vitest'; +import { routeRubyCall, callRouters } from '../../src/core/ingestion/call-routing.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; + +// ── Mock AST node helpers ──────────────────────────────────────────────────── + +/** + * Build a minimal mock tree-sitter node. Only the fields actually accessed + * by routeRubyCall are populated; everything else is left undefined so that + * accidental property reads surface as undefined (the same as a real node + * that lacks the field) rather than silently returning a wrong value. + */ + +interface MockNode { + type: string; + text: string; + isNamed?: boolean; + startPosition?: { row: number; col?: number }; + endPosition?: { row: number; col?: number }; + children?: MockNode[]; + parent?: MockNode | null; + previousSibling?: MockNode | null; + childForFieldName?: (name: string) => MockNode | undefined; +} + +/** Build a string node as tree-sitter-ruby emits it: string → string_content */ +function makeStringNode(content: string): MockNode { + const contentNode: MockNode = { type: 'string_content', text: content }; + return { + type: 'string', + text: `"${content}"`, + children: [contentNode], + }; +} + +/** + * Build a mock `call` node for require/require_relative with a single string + * argument. + */ +function makeRequireCallNode(path: string | null): MockNode { + const argChildren: MockNode[] = path !== null ? [makeStringNode(path)] : []; + const argList: MockNode = { type: 'argument_list', text: '', children: argChildren }; + const node: MockNode = { + type: 'call', + text: '', + childForFieldName: (name: string) => (name === 'arguments' ? argList : undefined), + }; + return node; +} + +/** + * Build a call node where the argument list contains a string node whose + * string_content child is absent (simulates a non-literal string argument). + */ +function makeRequireCallNodeNoContent(): MockNode { + const stringNodeNoContent: MockNode = { type: 'string', text: '""', children: [] }; + const argList: MockNode = { type: 'argument_list', text: '', children: [stringNodeNoContent] }; + return { + type: 'call', + text: '', + childForFieldName: (name: string) => (name === 'arguments' ? argList : undefined), + }; +} + +/** Build a mock call node for include/extend/prepend with a chain of parents. */ +function makeHeritageCallNode( + argNodes: MockNode[], + enclosingType: 'class' | 'module' | null, + enclosingName: string | null, + extraDepth = 0, +): MockNode { + const argList: MockNode = { type: 'argument_list', text: '', children: argNodes }; + const callNode: MockNode = { + type: 'call', + text: '', + parent: null, + childForFieldName: (name: string) => (name === 'arguments' ? argList : undefined), + }; + + if (enclosingType === null) { + // No enclosing class at all — parent chain ends without a class/module node + const intermediate: MockNode = { type: 'body', text: '', parent: null }; + callNode.parent = intermediate; + return callNode; + } + + // Build extra intermediate nodes to test deep parent walking + let leaf: MockNode = callNode; + for (let i = 0; i < extraDepth; i++) { + const wrapper: MockNode = { type: 'body_statement', text: '', parent: null }; + leaf.parent = wrapper; + leaf = wrapper; + } + + const nameNode: MockNode | undefined = + enclosingName ? { type: 'constant', text: enclosingName } : undefined; + + const classNode: MockNode = { + type: enclosingType, + text: '', + parent: null, + childForFieldName: (name: string) => (name === 'name' ? nameNode : undefined), + }; + leaf.parent = classNode; + + return callNode; +} + +/** Build a constant arg node (used as mixin name) */ +function makeConstantArg(text: string): MockNode { + return { type: 'constant', text }; +} + +/** Build a scope_resolution arg node (e.g. Foo::Bar) */ +function makeScopeResolutionArg(text: string): MockNode { + return { type: 'scope_resolution', text }; +} + +/** Build an identifier arg that is neither constant nor scope_resolution */ +function makeIdentifierArg(text: string): MockNode { + return { type: 'identifier', text }; +} + +/** Build a simple_symbol arg (used in attr_accessor etc.) */ +function makeSimpleSymbol(name: string, row = 0): MockNode { + return { + type: 'simple_symbol', + text: `:${name}`, + startPosition: { row }, + endPosition: { row }, + }; +} + +/** + * Build a call node for attr_accessor/attr_reader/attr_writer with optional + * preceding comment siblings. + */ +function makeAccessorCallNode( + symbolArgs: MockNode[], + previousSiblings: MockNode[] = [], +): MockNode { + const argList: MockNode = { type: 'argument_list', text: '', children: symbolArgs }; + + // Link previousSiblings as a chain (last element is the direct previousSibling) + let prevSibling: MockNode | null = null; + for (const s of previousSiblings) { + s.previousSibling = prevSibling; + prevSibling = s; + } + + const callNode: MockNode = { + type: 'call', + text: '', + previousSibling: prevSibling, + childForFieldName: (name: string) => (name === 'arguments' ? argList : undefined), + }; + return callNode; +} + +/** Build a comment node (isNamed = false by default, matching real tree-sitter Ruby) */ +function makeCommentNode(text: string, named = false): MockNode { + return { type: 'comment', text, isNamed: named }; +} + +/** Build a named non-comment sibling (causes yard-scan loop to stop) */ +function makeNamedSibling(type = 'expression_statement'): MockNode { + return { type, text: '', isNamed: true }; +} + +// ── require / require_relative ─────────────────────────────────────────────── + +describe('routeRubyCall — require / require_relative', () => { + it('require with a valid string path returns import with isRelative=false', () => { + const node = makeRequireCallNode('net/http'); + const result = routeRubyCall('require', node); + + expect(result).toEqual({ kind: 'import', importPath: 'net/http', isRelative: false }); + }); + + it('require_relative without leading dot prepends "./"', () => { + const node = makeRequireCallNode('models/user'); + const result = routeRubyCall('require_relative', node); + + expect(result).toEqual({ kind: 'import', importPath: './models/user', isRelative: true }); + }); + + it('require_relative with path already starting with "." does not double-prepend', () => { + const node = makeRequireCallNode('./helpers/formatter'); + const result = routeRubyCall('require_relative', node); + + expect(result).toEqual({ kind: 'import', importPath: './helpers/formatter', isRelative: true }); + }); + + it('require_relative with "../" prefix is left unchanged', () => { + const node = makeRequireCallNode('../shared/utils'); + const result = routeRubyCall('require_relative', node); + + expect(result).toEqual({ kind: 'import', importPath: '../shared/utils', isRelative: true }); + }); + + it('returns skip when there is no string_content node (non-literal argument)', () => { + const node = makeRequireCallNodeNoContent(); + expect(routeRubyCall('require', node)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when import path is an empty string', () => { + const node = makeRequireCallNode(''); + expect(routeRubyCall('require', node)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when import path contains a control character (\\x00)', () => { + const node = makeRequireCallNode('some\x00path'); + expect(routeRubyCall('require', node)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when import path contains a newline control character (\\n)', () => { + const node = makeRequireCallNode('path\ninjection'); + expect(routeRubyCall('require', node)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when import path exceeds 1024 characters', () => { + const longPath = 'a'.repeat(1025); + const node = makeRequireCallNode(longPath); + expect(routeRubyCall('require', node)).toEqual({ kind: 'skip' }); + }); + + it('accepts import path of exactly 1024 characters', () => { + const maxPath = 'a'.repeat(1024); + const node = makeRequireCallNode(maxPath); + const result = routeRubyCall('require', node); + expect(result).toEqual({ kind: 'import', importPath: maxPath, isRelative: false }); + }); + + it('returns skip when argument list has no string child at all', () => { + // argList has only a non-string child + const argList: MockNode = { + type: 'argument_list', + text: '', + children: [{ type: 'identifier', text: 'MY_CONST' }], + }; + const node: MockNode = { + type: 'call', + text: '', + childForFieldName: (name: string) => (name === 'arguments' ? argList : undefined), + }; + expect(routeRubyCall('require', node)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when childForFieldName is absent (undefined callNode fields)', () => { + // callNode has no childForFieldName method at all + const node: MockNode = { type: 'call', text: '' }; + expect(routeRubyCall('require', node)).toEqual({ kind: 'skip' }); + }); +}); + +// ── include / extend / prepend ─────────────────────────────────────────────── + +describe('routeRubyCall — include / extend / prepend', () => { + it('include with a single constant arg inside a class returns heritage', () => { + const node = makeHeritageCallNode([makeConstantArg('Serializable')], 'class', 'User'); + const result = routeRubyCall('include', node); + + expect(result).toEqual({ + kind: 'heritage', + items: [{ enclosingClass: 'User', mixinName: 'Serializable', heritageKind: 'include' }], + }); + }); + + it('extend with a scope_resolution arg (Foo::Bar) returns heritage', () => { + const node = makeHeritageCallNode([makeScopeResolutionArg('ActiveSupport::Concern')], 'class', 'Post'); + const result = routeRubyCall('extend', node); + + expect(result).toEqual({ + kind: 'heritage', + items: [{ enclosingClass: 'Post', mixinName: 'ActiveSupport::Concern', heritageKind: 'extend' }], + }); + }); + + it('prepend records heritageKind as "prepend"', () => { + const node = makeHeritageCallNode([makeConstantArg('Instrumented')], 'class', 'Service'); + const result = routeRubyCall('prepend', node); + + expect(result).toEqual({ + kind: 'heritage', + items: [{ enclosingClass: 'Service', mixinName: 'Instrumented', heritageKind: 'prepend' }], + }); + }); + + it('include inside a module (not a class) still resolves enclosing name', () => { + const node = makeHeritageCallNode([makeConstantArg('Helpers')], 'module', 'ApplicationHelper'); + const result = routeRubyCall('include', node); + + expect(result).toEqual({ + kind: 'heritage', + items: [{ enclosingClass: 'ApplicationHelper', mixinName: 'Helpers', heritageKind: 'include' }], + }); + }); + + it('include with multiple constant args produces one item per arg', () => { + const args = [makeConstantArg('Mod1'), makeConstantArg('Mod2'), makeConstantArg('Mod3')]; + const node = makeHeritageCallNode(args, 'class', 'MyClass'); + const result = routeRubyCall('include', node); + + expect(result).toEqual({ + kind: 'heritage', + items: [ + { enclosingClass: 'MyClass', mixinName: 'Mod1', heritageKind: 'include' }, + { enclosingClass: 'MyClass', mixinName: 'Mod2', heritageKind: 'include' }, + { enclosingClass: 'MyClass', mixinName: 'Mod3', heritageKind: 'include' }, + ], + }); + }); + + it('returns skip when no enclosing class or module is found in parent chain', () => { + const node = makeHeritageCallNode([makeConstantArg('Mod')], null, null); + expect(routeRubyCall('include', node)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when enclosing class node has no name child', () => { + // nameNode is undefined — childForFieldName('name') returns undefined + const argList: MockNode = { type: 'argument_list', text: '', children: [makeConstantArg('Mod')] }; + const classNode: MockNode = { + type: 'class', + text: '', + parent: null, + childForFieldName: (_name: string) => undefined, + }; + const bodyNode: MockNode = { type: 'body', text: '', parent: classNode }; + const callNode: MockNode = { + type: 'call', + text: '', + parent: bodyNode, + childForFieldName: (name: string) => (name === 'arguments' ? argList : undefined), + }; + expect(routeRubyCall('include', callNode)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when arg list contains only non-constant/non-scope_resolution args', () => { + const node = makeHeritageCallNode([makeIdentifierArg('some_var')], 'class', 'Foo'); + expect(routeRubyCall('include', node)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when arg list is empty', () => { + const node = makeHeritageCallNode([], 'class', 'Foo'); + expect(routeRubyCall('include', node)).toEqual({ kind: 'skip' }); + }); + + it('walks nested scopes to find the nearest enclosing class', () => { + // callNode is 5 levels deep inside a class body + const node = makeHeritageCallNode([makeConstantArg('DeepMixin')], 'class', 'DeepClass', 5); + const result = routeRubyCall('include', node); + + expect(result).toEqual({ + kind: 'heritage', + items: [{ enclosingClass: 'DeepClass', mixinName: 'DeepMixin', heritageKind: 'include' }], + }); + }); + + it('returns skip when parent depth exceeds MAX_PARENT_DEPTH (50)', () => { + // Build a chain of 51 intermediate nodes with no class/module in it + const argList: MockNode = { + type: 'argument_list', + text: '', + children: [makeConstantArg('Mod')], + }; + const callNode: MockNode = { + type: 'call', + text: '', + parent: null, + childForFieldName: (name: string) => (name === 'arguments' ? argList : undefined), + }; + + let current: MockNode = callNode; + // Create 51 parents — all plain body nodes, never a class/module + for (let i = 0; i < 51; i++) { + const parent: MockNode = { type: 'body_statement', text: '', parent: null }; + current.parent = parent; + current = parent; + } + + expect(routeRubyCall('include', callNode)).toEqual({ kind: 'skip' }); + }); + + it('finds class at exactly depth 50 (boundary — must succeed)', () => { + // 49 plain wrappers, then the class at depth 50 + const argList: MockNode = { + type: 'argument_list', + text: '', + children: [makeConstantArg('BoundaryMixin')], + }; + const callNode: MockNode = { + type: 'call', + text: '', + parent: null, + childForFieldName: (name: string) => (name === 'arguments' ? argList : undefined), + }; + + let leaf: MockNode = callNode; + for (let i = 0; i < 49; i++) { + const wrapper: MockNode = { type: 'body_statement', text: '', parent: null }; + leaf.parent = wrapper; + leaf = wrapper; + } + + const nameNode: MockNode = { type: 'constant', text: 'BoundaryClass' }; + const classNode: MockNode = { + type: 'class', + text: '', + parent: null, + childForFieldName: (name: string) => (name === 'name' ? nameNode : undefined), + }; + leaf.parent = classNode; + + const result = routeRubyCall('include', callNode); + expect(result).toEqual({ + kind: 'heritage', + items: [{ enclosingClass: 'BoundaryClass', mixinName: 'BoundaryMixin', heritageKind: 'include' }], + }); + }); + + it('skips non-constant args mixed with constant args, collecting only constants', () => { + const args = [ + makeIdentifierArg('local_var'), + makeConstantArg('ValidMixin'), + makeIdentifierArg('another_var'), + ]; + const node = makeHeritageCallNode(args, 'class', 'Foo'); + const result = routeRubyCall('include', node); + + expect(result).toEqual({ + kind: 'heritage', + items: [{ enclosingClass: 'Foo', mixinName: 'ValidMixin', heritageKind: 'include' }], + }); + }); +}); + +// ── attr_accessor / attr_reader / attr_writer ──────────────────────────────── + +describe('routeRubyCall — attr_accessor / attr_reader / attr_writer', () => { + it('attr_accessor with a single symbol returns a property item', () => { + const node = makeAccessorCallNode([makeSimpleSymbol('name', 5)]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toEqual({ + kind: 'properties', + items: [{ propName: 'name', accessorType: 'attr_accessor', startLine: 5, endLine: 5 }], + }); + }); + + it('attr_reader sets accessorType to "attr_reader"', () => { + const node = makeAccessorCallNode([makeSimpleSymbol('age', 3)]); + const result = routeRubyCall('attr_reader', node); + + expect(result).toEqual({ + kind: 'properties', + items: [{ propName: 'age', accessorType: 'attr_reader', startLine: 3, endLine: 3 }], + }); + }); + + it('attr_writer sets accessorType to "attr_writer"', () => { + const node = makeAccessorCallNode([makeSimpleSymbol('email', 7)]); + const result = routeRubyCall('attr_writer', node); + + expect(result).toEqual({ + kind: 'properties', + items: [{ propName: 'email', accessorType: 'attr_writer', startLine: 7, endLine: 7 }], + }); + }); + + it('strips leading colon from symbol text', () => { + // makeSimpleSymbol already prefixes with ':', this validates the slice(1) branch + const symNode: MockNode = { + type: 'simple_symbol', + text: ':title', + startPosition: { row: 2 }, + endPosition: { row: 2 }, + }; + const node = makeAccessorCallNode([symNode]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toMatchObject({ kind: 'properties', items: [{ propName: 'title' }] }); + }); + + it('handles symbol text without colon prefix (no double-strip)', () => { + // Simulate a symbol whose text does NOT start with ':' + const symNode: MockNode = { + type: 'simple_symbol', + text: 'status', + startPosition: { row: 1 }, + endPosition: { row: 1 }, + }; + const node = makeAccessorCallNode([symNode]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toMatchObject({ kind: 'properties', items: [{ propName: 'status' }] }); + }); + + it('multiple symbols produce one item each', () => { + const args = [makeSimpleSymbol('first_name', 10), makeSimpleSymbol('last_name', 10), makeSimpleSymbol('dob', 10)]; + const node = makeAccessorCallNode(args); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toEqual({ + kind: 'properties', + items: [ + { propName: 'first_name', accessorType: 'attr_accessor', startLine: 10, endLine: 10 }, + { propName: 'last_name', accessorType: 'attr_accessor', startLine: 10, endLine: 10 }, + { propName: 'dob', accessorType: 'attr_accessor', startLine: 10, endLine: 10 }, + ], + }); + }); + + it('extracts simple YARD @return [Type] from preceding comment', () => { + const comment = makeCommentNode('# @return [Address]'); + const node = makeAccessorCallNode([makeSimpleSymbol('address', 20)], [comment]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toMatchObject({ + kind: 'properties', + items: [{ propName: 'address', declaredType: 'Address' }], + }); + }); + + it('extracts only the leading type name from compound YARD type (Array<User> → "Array")', () => { + // The regex captures "Array<User>"; the simple match grabs the first uppercase word "Array" + const comment = makeCommentNode('# @return [Array<User>]'); + const node = makeAccessorCallNode([makeSimpleSymbol('users', 15)], [comment]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toMatchObject({ + kind: 'properties', + items: [{ declaredType: 'Array' }], + }); + }); + + it('extracts type from YARD comment with extra whitespace inside brackets', () => { + const comment = makeCommentNode('# @return [ Integer ]'); + const node = makeAccessorCallNode([makeSimpleSymbol('count', 8)], [comment]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toMatchObject({ + kind: 'properties', + items: [{ declaredType: 'Integer' }], + }); + }); + + it('does not set declaredType when no YARD comment precedes the call', () => { + const node = makeAccessorCallNode([makeSimpleSymbol('score', 12)]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toMatchObject({ kind: 'properties', items: [{ propName: 'score' }] }); + const item = (result as any).items[0]; + expect(item.declaredType).toBeUndefined(); + }); + + it('does not set declaredType when comment has no @return annotation', () => { + const comment = makeCommentNode('# This accessor stores the user name'); + const node = makeAccessorCallNode([makeSimpleSymbol('user_name', 9)], [comment]); + const result = routeRubyCall('attr_accessor', node); + + const item = (result as any).items[0]; + expect(item.declaredType).toBeUndefined(); + }); + + it('does not set declaredType when YARD type starts with lowercase (not ^[A-Z])', () => { + // e.g. "@return [string]" — lowercase first char fails the simple = raw.match(/^([A-Z]\w*)/) + const comment = makeCommentNode('# @return [string]'); + const node = makeAccessorCallNode([makeSimpleSymbol('label', 4)], [comment]); + const result = routeRubyCall('attr_accessor', node); + + const item = (result as any).items[0]; + expect(item.declaredType).toBeUndefined(); + }); + + it('stops sibling scan at a non-comment named sibling before reaching a comment', () => { + // Ordered as [comment, namedSibling] — namedSibling is the direct previousSibling, + // so the scan hits it first and stops before reading the comment + const yardComment = makeCommentNode('# @return [User]'); + const named = makeNamedSibling(); + const node = makeAccessorCallNode([makeSimpleSymbol('owner', 6)], [yardComment, named]); + // named is last in the array → becomes direct previousSibling + const result = routeRubyCall('attr_accessor', node); + + const item = (result as any).items[0]; + expect(item.declaredType).toBeUndefined(); + }); + + it('continues past unnamed (non-named) siblings to find a YARD comment', () => { + // An unnamed whitespace/punctuation node between the comment and the call + const unnamedNode: MockNode = { type: 'newline', text: '\n', isNamed: false }; + const comment = makeCommentNode('# @return [Order]'); + // siblings in order oldest→newest; the last becomes the direct previousSibling + const node = makeAccessorCallNode([makeSimpleSymbol('order', 30)], [comment, unnamedNode]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toMatchObject({ + kind: 'properties', + items: [{ declaredType: 'Order' }], + }); + }); + + it('returns skip when arg list contains no simple_symbol nodes', () => { + // Only an identifier node — not a symbol + const identArg: MockNode = { type: 'identifier', text: 'some_var' }; + const node = makeAccessorCallNode([identArg]); + expect(routeRubyCall('attr_accessor', node)).toEqual({ kind: 'skip' }); + }); + + it('returns skip when arg list is empty', () => { + const node = makeAccessorCallNode([]); + expect(routeRubyCall('attr_accessor', node)).toEqual({ kind: 'skip' }); + }); + + it('records correct startLine and endLine from symbol node positions', () => { + const sym: MockNode = { + type: 'simple_symbol', + text: ':created_at', + startPosition: { row: 42 }, + endPosition: { row: 42 }, + }; + const node = makeAccessorCallNode([sym]); + const result = routeRubyCall('attr_accessor', node); + + expect(result).toMatchObject({ + kind: 'properties', + items: [{ startLine: 42, endLine: 42 }], + }); + }); +}); + +// ── default case ───────────────────────────────────────────────────────────── + +describe('routeRubyCall — default (unknown method name)', () => { + it('returns {kind: "call"} for an arbitrary method name', () => { + const node: MockNode = { type: 'call', text: '' }; + expect(routeRubyCall('some_method', node)).toEqual({ kind: 'call' }); + }); + + it('returns {kind: "call"} for an empty method name string', () => { + const node: MockNode = { type: 'call', text: '' }; + expect(routeRubyCall('', node)).toEqual({ kind: 'call' }); + }); + + it('returns {kind: "call"} for a realistic method name (save, render, etc.)', () => { + const node: MockNode = { type: 'call', text: '' }; + expect(routeRubyCall('render', node)).toEqual({ kind: 'call' }); + expect(routeRubyCall('save', node)).toEqual({ kind: 'call' }); + expect(routeRubyCall('destroy', node)).toEqual({ kind: 'call' }); + }); +}); + +// ── callRouters dispatch table ──────────────────────────────────────────────── + +describe('callRouters dispatch table', () => { + it('non-Ruby languages return null (noRouting passthrough)', () => { + const dummyNode = { type: 'call', text: '' }; + const nonRubyLanguages: SupportedLanguages[] = [ + SupportedLanguages.JavaScript, + SupportedLanguages.TypeScript, + SupportedLanguages.Python, + SupportedLanguages.Java, + SupportedLanguages.Kotlin, + SupportedLanguages.Go, + SupportedLanguages.Rust, + SupportedLanguages.CSharp, + SupportedLanguages.PHP, + SupportedLanguages.Swift, + SupportedLanguages.CPlusPlus, + SupportedLanguages.C, + ]; + for (const lang of nonRubyLanguages) { + expect(callRouters[lang]('require', dummyNode)).toBeNull(); + } + }); + + it('Ruby router is routeRubyCall (delegates correctly for require)', () => { + const node = makeRequireCallNode('json'); + const result = callRouters[SupportedLanguages.Ruby]('require', node); + expect(result).toEqual({ kind: 'import', importPath: 'json', isRelative: false }); + }); + + it('Ruby router returns {kind: "call"} for an unknown method name', () => { + const node: MockNode = { type: 'call', text: '' }; + const result = callRouters[SupportedLanguages.Ruby]('render', node); + expect(result).toEqual({ kind: 'call' }); + }); + + it('callRouters covers every SupportedLanguages value (no missing key)', () => { + const allLanguages = Object.values(SupportedLanguages) as SupportedLanguages[]; + for (const lang of allLanguages) { + expect(typeof callRouters[lang]).toBe('function'); + } + }); +}); diff --git a/gitnexus/test/unit/calltool-dispatch.test.ts b/gitnexus/test/unit/calltool-dispatch.test.ts new file mode 100644 index 0000000000..50263f3561 --- /dev/null +++ b/gitnexus/test/unit/calltool-dispatch.test.ts @@ -0,0 +1,584 @@ +/** + * Unit Tests: LocalBackend callTool dispatch & lifecycle + * + * Tests the callTool dispatch logic, resolveRepo, init/disconnect, + * error cases, and silent failure patterns — all with mocked LadybugDB. + * + * These are pure unit tests that mock the LadybugDB layer to test + * the dispatch and error handling logic in isolation. + */ +import { describe, it, expect, vi, beforeEach } from 'vitest'; + +// We need to mock the LadybugDB adapter and repo-manager BEFORE importing LocalBackend +vi.mock('../../src/mcp/core/lbug-adapter.js', () => ({ + initLbug: vi.fn().mockResolvedValue(undefined), + executeQuery: vi.fn().mockResolvedValue([]), + executeParameterized: vi.fn().mockResolvedValue([]), + closeLbug: vi.fn().mockResolvedValue(undefined), + isLbugReady: vi.fn().mockReturnValue(true), +})); + +vi.mock('../../src/storage/repo-manager.js', () => ({ + listRegisteredRepos: vi.fn().mockResolvedValue([]), + cleanupOldKuzuFiles: vi.fn().mockResolvedValue({ found: false, needsReindex: false }), +})); + +// Also mock the search modules to avoid loading onnxruntime +vi.mock('../../src/core/search/bm25-index.js', () => ({ + searchFTSFromLbug: vi.fn().mockResolvedValue([]), +})); + +vi.mock('../../src/mcp/core/embedder.js', () => ({ + embedQuery: vi.fn().mockResolvedValue([]), + getEmbeddingDims: vi.fn().mockReturnValue(384), +})); + +import { LocalBackend } from '../../src/mcp/local/local-backend.js'; +import { listRegisteredRepos, cleanupOldKuzuFiles } from '../../src/storage/repo-manager.js'; +import { initLbug, executeQuery, executeParameterized, isLbugReady, closeLbug } from '../../src/mcp/core/lbug-adapter.js'; + +// ─── Helpers ───────────────────────────────────────────────────────── + +const MOCK_REPO_ENTRY = { + name: 'test-project', + path: '/tmp/test-project', + storagePath: '/tmp/.gitnexus/test-project', + indexedAt: '2024-06-01T12:00:00Z', + lastCommit: 'abc1234567890', + stats: { files: 10, nodes: 50, edges: 100, communities: 3, processes: 5 }, +}; + +function setupSingleRepo() { + (listRegisteredRepos as any).mockResolvedValue([MOCK_REPO_ENTRY]); +} + +function setupMultipleRepos() { + (listRegisteredRepos as any).mockResolvedValue([ + MOCK_REPO_ENTRY, + { + ...MOCK_REPO_ENTRY, + name: 'other-project', + path: '/tmp/other-project', + storagePath: '/tmp/.gitnexus/other-project', + }, + ]); +} + +function setupNoRepos() { + (listRegisteredRepos as any).mockResolvedValue([]); +} + +// ─── LocalBackend lifecycle ────────────────────────────────────────── + +describe('LocalBackend.init', () => { + let backend: LocalBackend; + + beforeEach(() => { + backend = new LocalBackend(); + vi.clearAllMocks(); + }); + + it('returns true when repos are available', async () => { + setupSingleRepo(); + const result = await backend.init(); + expect(result).toBe(true); + }); + + it('returns false when no repos are registered', async () => { + setupNoRepos(); + const result = await backend.init(); + expect(result).toBe(false); + }); + + it('calls listRegisteredRepos with validate: true', async () => { + setupSingleRepo(); + await backend.init(); + expect(listRegisteredRepos).toHaveBeenCalledWith({ validate: true }); + }); +}); + +describe('LocalBackend.disconnect', () => { + let backend: LocalBackend; + + beforeEach(() => { + backend = new LocalBackend(); + vi.clearAllMocks(); + }); + + it('does not throw when no repos are initialized', async () => { + setupNoRepos(); + await backend.init(); + await expect(backend.disconnect()).resolves.not.toThrow(); + }); + + it('calls closeLbug on disconnect', async () => { + setupSingleRepo(); + await backend.init(); + await backend.disconnect(); + expect(closeLbug).toHaveBeenCalled(); + }); +}); + +// ─── callTool dispatch ─────────────────────────────────────────────── + +describe('LocalBackend.callTool', () => { + let backend: LocalBackend; + + beforeEach(async () => { + vi.clearAllMocks(); + backend = new LocalBackend(); + setupSingleRepo(); + await backend.init(); + }); + + it('routes list_repos without needing repo param', async () => { + const result = await backend.callTool('list_repos', {}); + expect(Array.isArray(result)).toBe(true); + expect(result[0].name).toBe('test-project'); + }); + + it('throws for unknown tool name', async () => { + await expect(backend.callTool('nonexistent_tool', {})) + .rejects.toThrow('Unknown tool: nonexistent_tool'); + }); + + it('dispatches query tool', async () => { + (executeParameterized as any).mockResolvedValue([]); + const result = await backend.callTool('query', { query: 'auth' }); + expect(result).toHaveProperty('processes'); + expect(result).toHaveProperty('definitions'); + }); + + it('query tool returns error for empty query', async () => { + const result = await backend.callTool('query', { query: '' }); + expect(result.error).toContain('query parameter is required'); + }); + + it('query tool returns error for whitespace-only query', async () => { + const result = await backend.callTool('query', { query: ' ' }); + expect(result.error).toContain('query parameter is required'); + }); + + it('dispatches cypher tool and blocks write queries', async () => { + const result = await backend.callTool('cypher', { query: 'CREATE (n:Test)' }); + expect(result).toHaveProperty('error'); + expect(result.error).toContain('Write operations'); + }); + + it('dispatches cypher tool with valid read query', async () => { + (executeQuery as any).mockResolvedValue([ + { name: 'test', filePath: 'src/test.ts' }, + ]); + const result = await backend.callTool('cypher', { + query: 'MATCH (n:Function) RETURN n.name AS name, n.filePath AS filePath LIMIT 5', + }); + // formatCypherAsMarkdown returns { markdown, row_count } for tabular results + expect(result).toHaveProperty('markdown'); + expect(result).toHaveProperty('row_count'); + expect(result.row_count).toBe(1); + }); + + it('dispatches context tool', async () => { + (executeParameterized as any).mockResolvedValue([ + { id: 'func:main', name: 'main', type: 'Function', filePath: 'src/index.ts', startLine: 1, endLine: 10 }, + ]); + const result = await backend.callTool('context', { name: 'main' }); + expect(result.status).toBe('found'); + expect(result.symbol.name).toBe('main'); + }); + + it('context tool returns error when name and uid are both missing', async () => { + const result = await backend.callTool('context', {}); + expect(result.error).toContain('Either "name" or "uid"'); + }); + + it('context tool returns not-found for missing symbol', async () => { + (executeParameterized as any).mockResolvedValue([]); + const result = await backend.callTool('context', { name: 'doesNotExist' }); + expect(result.error).toContain('not found'); + }); + + it('context tool returns disambiguation for multiple matches', async () => { + (executeParameterized as any).mockResolvedValue([ + { id: 'func:main:1', name: 'main', type: 'Function', filePath: 'src/a.ts', startLine: 1, endLine: 5 }, + { id: 'func:main:2', name: 'main', type: 'Function', filePath: 'src/b.ts', startLine: 1, endLine: 5 }, + ]); + const result = await backend.callTool('context', { name: 'main' }); + expect(result.status).toBe('ambiguous'); + expect(result.candidates).toHaveLength(2); + }); + + it('dispatches impact tool', async () => { + // impact() calls executeParameterized to find target, then executeQuery for traversal + (executeParameterized as any).mockResolvedValue([ + { id: 'func:main', name: 'main', type: 'Function', filePath: 'src/index.ts' }, + ]); + (executeQuery as any).mockResolvedValue([]); + + const result = await backend.callTool('impact', { target: 'main', direction: 'upstream' }); + expect(result).toBeDefined(); + expect(result.target).toBeDefined(); + }); + + it('dispatches detect_changes tool', async () => { + // detect_changes calls execFileSync which we haven't mocked at module level, + // so it will throw a git error — that's fine, we test the error path + const result = await backend.callTool('detect_changes', { scope: 'unstaged' }); + // Should either return changes or a git error + expect(result).toBeDefined(); + expect(result.error || result.summary).toBeDefined(); + }); + + it('dispatches rename tool', async () => { + (executeParameterized as any) + .mockResolvedValueOnce([ + { id: 'func:oldName', name: 'oldName', type: 'Function', filePath: 'src/test.ts', startLine: 1, endLine: 5 }, + ]) + .mockResolvedValue([]); + + const result = await backend.callTool('rename', { + symbol_name: 'oldName', + new_name: 'newName', + dry_run: true, + }); + expect(result).toBeDefined(); + }); + + it('rename returns error when both symbol_name and symbol_uid are missing', async () => { + const result = await backend.callTool('rename', { new_name: 'newName' }); + expect(result.error).toContain('Either symbol_name or symbol_uid'); + }); + + // Legacy tool aliases + it('dispatches "search" as alias for query', async () => { + (executeParameterized as any).mockResolvedValue([]); + const result = await backend.callTool('search', { query: 'auth' }); + expect(result).toHaveProperty('processes'); + }); + + it('dispatches "explore" as alias for context', async () => { + (executeParameterized as any).mockResolvedValue([ + { id: 'func:main', name: 'main', type: 'Function', filePath: 'src/index.ts', startLine: 1, endLine: 10 }, + ]); + const result = await backend.callTool('explore', { name: 'main' }); + // explore calls context — which may return found or ambiguous depending on mock + expect(result).toBeDefined(); + expect(result.status === 'found' || result.symbol || result.error === undefined).toBeTruthy(); + }); +}); + +// ─── Repo resolution ──────────────────────────────────────────────── + +describe('LocalBackend.resolveRepo', () => { + let backend: LocalBackend; + + beforeEach(async () => { + vi.clearAllMocks(); + backend = new LocalBackend(); + }); + + it('resolves single repo without param', async () => { + setupSingleRepo(); + await backend.init(); + const result = await backend.callTool('list_repos', {}); + expect(result).toHaveLength(1); + }); + + it('throws when no repos are registered', async () => { + setupNoRepos(); + await backend.init(); + await expect(backend.callTool('query', { query: 'test' })) + .rejects.toThrow('No indexed repositories'); + }); + + it('throws for ambiguous repos without param', async () => { + setupMultipleRepos(); + await backend.init(); + await expect(backend.callTool('query', { query: 'test' })) + .rejects.toThrow('Multiple repositories indexed'); + }); + + it('resolves repo by name parameter', async () => { + setupMultipleRepos(); + await backend.init(); + // With repo param, it should resolve correctly + (executeParameterized as any).mockResolvedValue([]); + const result = await backend.callTool('query', { + query: 'auth', + repo: 'test-project', + }); + expect(result).toHaveProperty('processes'); + }); + + it('throws for unknown repo name', async () => { + setupSingleRepo(); + await backend.init(); + await expect(backend.callTool('query', { query: 'test', repo: 'nonexistent' })) + .rejects.toThrow('not found'); + }); + + it('resolves repo case-insensitively', async () => { + setupSingleRepo(); + await backend.init(); + (executeParameterized as any).mockResolvedValue([]); + // Should match even with different case + const result = await backend.callTool('query', { + query: 'test', + repo: 'Test-Project', + }); + expect(result).toHaveProperty('processes'); + }); + + it('refreshes registry on repo miss', async () => { + setupNoRepos(); + await backend.init(); + + // Now make a repo appear + (listRegisteredRepos as any).mockResolvedValue([MOCK_REPO_ENTRY]); + + // The resolve should re-read the registry and find the new repo + (executeParameterized as any).mockResolvedValue([]); + const result = await backend.callTool('query', { + query: 'test', + repo: 'test-project', + }); + expect(result).toHaveProperty('processes'); + // listRegisteredRepos should have been called again + expect(listRegisteredRepos).toHaveBeenCalledTimes(2); // once in init, once in refreshRepos + }); +}); + +// ─── getContext ────────────────────────────────────────────────────── + +describe('LocalBackend.getContext', () => { + let backend: LocalBackend; + + beforeEach(async () => { + vi.clearAllMocks(); + backend = new LocalBackend(); + setupSingleRepo(); + await backend.init(); + }); + + it('returns context for single repo without specifying id', () => { + const ctx = backend.getContext(); + expect(ctx).not.toBeNull(); + expect(ctx!.projectName).toBe('test-project'); + expect(ctx!.stats.fileCount).toBe(10); + expect(ctx!.stats.functionCount).toBe(50); + }); + + it('returns context by repo id', () => { + const ctx = backend.getContext('test-project'); + expect(ctx).not.toBeNull(); + expect(ctx!.projectName).toBe('test-project'); + }); + + it('returns single repo context even with unknown id (single-repo fallback)', () => { + // When only 1 repo is registered, getContext falls through the id check + // and returns the single repo's context. This is intentional behavior. + const ctx = backend.getContext('nonexistent'); + // The id doesn't match, but since repos.size === 1, it returns that single context + // This is the actual behavior — test documents it + expect(ctx).not.toBeNull(); + expect(ctx!.projectName).toBe('test-project'); + }); +}); + +// ─── LadybugDB lazy initialization ────────────────────────────────────── + +describe('ensureInitialized', () => { + let backend: LocalBackend; + + beforeEach(async () => { + vi.clearAllMocks(); + backend = new LocalBackend(); + setupSingleRepo(); + await backend.init(); + }); + + it('calls initLbug on first tool call', async () => { + (executeParameterized as any).mockResolvedValue([]); + await backend.callTool('query', { query: 'test' }); + expect(initLbug).toHaveBeenCalled(); + }); + + it('retries initLbug if connection was evicted', async () => { + (executeParameterized as any).mockResolvedValue([]); + // First call initializes + await backend.callTool('query', { query: 'test' }); + expect(initLbug).toHaveBeenCalledTimes(1); + + // Simulate idle eviction + (isLbugReady as any).mockReturnValueOnce(false); + await backend.callTool('query', { query: 'test' }); + expect(initLbug).toHaveBeenCalledTimes(2); + }); + + it('handles initLbug failure gracefully', async () => { + (initLbug as any).mockRejectedValueOnce(new Error('DB locked')); + await expect(backend.callTool('query', { query: 'test' })) + .rejects.toThrow('DB locked'); + }); +}); + +// ─── Cypher write blocking through callTool ────────────────────────── + +describe('callTool cypher write blocking', () => { + let backend: LocalBackend; + + beforeEach(async () => { + vi.clearAllMocks(); + backend = new LocalBackend(); + setupSingleRepo(); + await backend.init(); + }); + + const writeQueries = [ + 'CREATE (n:Function {name: "test"})', + 'MATCH (n) DELETE n', + 'MATCH (n) SET n.name = "hacked"', + 'MERGE (n:Function {name: "test"})', + 'MATCH (n) REMOVE n.name', + 'DROP TABLE Function', + 'ALTER TABLE Function ADD COLUMN foo STRING', + 'COPY Function FROM "file.csv"', + 'MATCH (n) DETACH DELETE n', + ]; + + for (const query of writeQueries) { + it(`blocks write query: ${query.slice(0, 30)}...`, async () => { + const result = await backend.callTool('cypher', { query }); + expect(result).toHaveProperty('error'); + expect(result.error).toContain('Write operations'); + }); + } + + it('allows read query through callTool', async () => { + (executeQuery as any).mockResolvedValue([]); + const result = await backend.callTool('cypher', { + query: 'MATCH (n:Function) RETURN n.name LIMIT 5', + }); + // Should not have error property with write-block message + expect(result.error).toBeUndefined(); + }); +}); + +// ─── listRepos ────────────────────────────────────────────────────── + +describe('LocalBackend.listRepos', () => { + let backend: LocalBackend; + + beforeEach(async () => { + vi.clearAllMocks(); + backend = new LocalBackend(); + }); + + it('returns empty array when no repos', async () => { + setupNoRepos(); + await backend.init(); + const repos = await backend.callTool('list_repos', {}); + expect(repos).toEqual([]); + }); + + it('returns repo metadata', async () => { + setupSingleRepo(); + await backend.init(); + const repos = await backend.callTool('list_repos', {}); + expect(repos).toHaveLength(1); + expect(repos[0]).toEqual(expect.objectContaining({ + name: 'test-project', + path: '/tmp/test-project', + indexedAt: expect.any(String), + lastCommit: expect.any(String), + })); + }); + + it('re-reads registry on each listRepos call', async () => { + setupSingleRepo(); + await backend.init(); + await backend.callTool('list_repos', {}); + await backend.callTool('list_repos', {}); + // listRegisteredRepos called: once in init, once per listRepos + expect(listRegisteredRepos).toHaveBeenCalledTimes(3); + }); +}); + +// ─── Cypher LadybugDB not ready ──────────────────────────────────────── + +describe('cypher tool LadybugDB not ready', () => { + let backend: LocalBackend; + + beforeEach(async () => { + vi.clearAllMocks(); + backend = new LocalBackend(); + setupSingleRepo(); + await backend.init(); + }); + + it('returns error when LadybugDB is not ready', async () => { + (isLbugReady as any).mockReturnValue(false); + // initLbug will succeed but isLbugReady returns false after ensureInitialized + // Actually ensureInitialized checks isLbugReady and re-inits — let's make that pass + // then the cypher method checks isLbugReady again + (isLbugReady as any) + .mockReturnValueOnce(false) // ensureInitialized check + .mockReturnValueOnce(false); // cypher's own check + + const result = await backend.callTool('cypher', { + query: 'MATCH (n) RETURN n LIMIT 1', + }); + expect(result.error).toContain('LadybugDB not ready'); + }); +}); + +// ─── formatCypherAsMarkdown ────────────────────────────────────────── + +describe('cypher result formatting', () => { + let backend: LocalBackend; + + beforeEach(async () => { + // Full reset of all mocks to prevent state leaking from other tests + vi.resetAllMocks(); + (listRegisteredRepos as any).mockResolvedValue([MOCK_REPO_ENTRY]); + (cleanupOldKuzuFiles as any).mockResolvedValue({ found: false, needsReindex: false }); + (initLbug as any).mockResolvedValue(undefined); + (isLbugReady as any).mockReturnValue(true); + (closeLbug as any).mockResolvedValue(undefined); + (executeParameterized as any).mockResolvedValue([]); + + backend = new LocalBackend(); + await backend.init(); + }); + + it('formats tabular results as markdown table', async () => { + (executeQuery as any).mockResolvedValue([ + { name: 'main', filePath: 'src/index.ts' }, + { name: 'helper', filePath: 'src/utils.ts' }, + ]); + const result = await backend.callTool('cypher', { + query: 'MATCH (n:Function) RETURN n.name AS name, n.filePath AS filePath', + }); + expect(result).toHaveProperty('markdown'); + expect(result.markdown).toContain('name'); + expect(result.markdown).toContain('main'); + expect(result.row_count).toBe(2); + }); + + it('returns empty array as-is', async () => { + (executeQuery as any).mockResolvedValue([]); + const result = await backend.callTool('cypher', { + query: 'MATCH (n:Function) RETURN n.name LIMIT 0', + }); + expect(result).toEqual([]); + }); + + it('returns error object when cypher fails', async () => { + (executeQuery as any).mockRejectedValue(new Error('Syntax error')); + const result = await backend.callTool('cypher', { + query: 'INVALID CYPHER SYNTAX', + }); + expect(result).toHaveProperty('error'); + expect(result.error).toContain('Syntax error'); + }); +}); diff --git a/gitnexus/test/unit/cli-commands.test.ts b/gitnexus/test/unit/cli-commands.test.ts new file mode 100644 index 0000000000..81d1c90dc1 --- /dev/null +++ b/gitnexus/test/unit/cli-commands.test.ts @@ -0,0 +1,64 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; + +// Mock all the heavy imports before importing index +vi.mock('../../src/cli/analyze.js', () => ({ + analyzeCommand: vi.fn(), +})); +vi.mock('../../src/cli/mcp.js', () => ({ + mcpCommand: vi.fn(), +})); +vi.mock('../../src/cli/setup.js', () => ({ + setupCommand: vi.fn(), +})); + +describe('CLI commands', () => { + describe('version', () => { + it('package.json has a valid version string', async () => { + const pkg = await import('../../package.json', { with: { type: 'json' } }); + expect(pkg.default.version).toMatch(/^\d+\.\d+\.\d+/); + }); + }); + + describe('package.json scripts', () => { + it('has test scripts configured', async () => { + const pkg = await import('../../package.json', { with: { type: 'json' } }); + expect(pkg.default.scripts.test).toBeDefined(); + expect(pkg.default.scripts['test:integration']).toBeDefined(); + expect(pkg.default.scripts['test:unit']).toBeDefined(); + }); + + it('has build script', async () => { + const pkg = await import('../../package.json', { with: { type: 'json' } }); + expect(pkg.default.scripts.build).toBeDefined(); + }); + }); + + describe('package.json bin entry', () => { + it('exposes gitnexus binary', async () => { + const pkg = await import('../../package.json', { with: { type: 'json' } }); + expect(pkg.default.bin).toBeDefined(); + expect(pkg.default.bin.gitnexus || pkg.default.bin).toBeDefined(); + }); + }); + + describe('analyzeCommand', () => { + it('is a function', async () => { + const { analyzeCommand } = await import('../../src/cli/analyze.js'); + expect(typeof analyzeCommand).toBe('function'); + }); + }); + + describe('mcpCommand', () => { + it('is a function', async () => { + const { mcpCommand } = await import('../../src/cli/mcp.js'); + expect(typeof mcpCommand).toBe('function'); + }); + }); + + describe('setupCommand', () => { + it('is a function', async () => { + const { setupCommand } = await import('../../src/cli/setup.js'); + expect(typeof setupCommand).toBe('function'); + }); + }); +}); diff --git a/gitnexus/test/unit/cli-index-help.test.ts b/gitnexus/test/unit/cli-index-help.test.ts new file mode 100644 index 0000000000..83eed651c1 --- /dev/null +++ b/gitnexus/test/unit/cli-index-help.test.ts @@ -0,0 +1,45 @@ +import { spawnSync } from 'node:child_process'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { describe, expect, it } from 'vitest'; + +const testDir = path.dirname(fileURLToPath(import.meta.url)); +const repoRoot = path.resolve(testDir, '../..'); +const cliEntry = path.join(repoRoot, 'src/cli/index.ts'); + +function runHelp(command: string) { + return spawnSync(process.execPath, ['--import', 'tsx', cliEntry, command, '--help'], { + cwd: repoRoot, + encoding: 'utf8', + }); +} + +describe('CLI help surface', () => { + it('query help keeps advanced search options without importing analyze deps', () => { + const result = runHelp('query'); + + expect(result.status).toBe(0); + expect(result.stdout).toContain('--context <text>'); + expect(result.stdout).toContain('--goal <text>'); + expect(result.stdout).toContain('--content'); + expect(result.stderr).not.toContain('tree-sitter-kotlin'); + }); + + it('context help keeps optional name and disambiguation flags', () => { + const result = runHelp('context'); + + expect(result.status).toBe(0); + expect(result.stdout).toContain('context [options] [name]'); + expect(result.stdout).toContain('--uid <uid>'); + expect(result.stdout).toContain('--file <path>'); + }); + + it('impact help keeps repo and include-tests flags', () => { + const result = runHelp('impact'); + + expect(result.status).toBe(0); + expect(result.stdout).toContain('--depth <n>'); + expect(result.stdout).toContain('--include-tests'); + expect(result.stdout).toContain('--repo <name>'); + }); +}); diff --git a/gitnexus/test/unit/cohesion-consistency.test.ts b/gitnexus/test/unit/cohesion-consistency.test.ts new file mode 100644 index 0000000000..112ec2a736 --- /dev/null +++ b/gitnexus/test/unit/cohesion-consistency.test.ts @@ -0,0 +1,292 @@ +/** + * Unit tests for cohesion formula consistency. + * + * Verifies that calculateCohesion (module-private) uses the internal edge ratio + * formula: internalEdges / totalEdges, NOT graph density (internalEdges / maxPossibleEdges). + * + * Since calculateCohesion is not exported, all tests exercise it indirectly through + * processCommunities — the public export. Graphs are built so that Leiden's community + * assignment is deterministic (disconnected cliques with strong internal connectivity). + */ +import { describe, it, expect } from 'vitest'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import type { GraphNode, GraphRelationship } from '../../src/core/graph/types.js'; +import { processCommunities } from '../../src/core/ingestion/community-processor.js'; + +// ============================================================================ +// FIXTURE HELPERS +// ============================================================================ + +/** Create a GraphNode with commonly-needed properties */ +function makeNode( + id: string, + name: string, + label: GraphNode['label'], + filePath: string, +): GraphNode { + return { + id, + label, + properties: { name, filePath, startLine: 1, endLine: 10, isExported: false }, + }; +} + +/** Create a CALLS relationship between two nodes */ +function makeRel( + id: string, + sourceId: string, + targetId: string, +): GraphRelationship { + return { id, sourceId, targetId, type: 'CALLS', confidence: 1.0, reason: '' }; +} + +/** Add a fully-connected clique of Function nodes to the graph */ +function addClique( + graph: ReturnType<typeof createKnowledgeGraph>, + prefix: string, + folder: string, + size: number, +): string[] { + const ids: string[] = []; + for (let i = 0; i < size; i++) { + const id = `fn:${prefix}${i}`; + ids.push(id); + graph.addNode(makeNode(id, `${prefix}Fn${i}`, 'Function', `/src/${folder}/f${i}.ts`)); + } + // Fully connect all pairs + let relIdx = 0; + for (let i = 0; i < size; i++) { + for (let j = i + 1; j < size; j++) { + graph.addRelationship(makeRel(`rel:${prefix}_${relIdx++}`, ids[i], ids[j])); + } + } + return ids; +} + +// ============================================================================ +// TESTS +// ============================================================================ + +describe('calculateCohesion — internal edge ratio', () => { + /** + * Build a 4-node fully connected clique with 2 external boundary edges. + * For the clique community: + * - 4 nodes, 6 internal edges (undirected) + * - 2 external edges (one from node0, one from node1 to outside nodes) + * - Each undirected edge is traversed twice in forEachNeighbor + * - Internal traversals: 6 edges * 2 = 12 (each internal edge counted from both endpoints) + * BUT only edges where BOTH endpoints are in the clique count. node0 has 3 internal + 1 external neighbor, + * node1 has 3 internal + 1 external neighbor, node2 has 3 internal, node3 has 3 internal. + * - Total neighbor traversals from clique members: (3+1) + (3+1) + 3 + 3 = 14 + * - Internal traversals: 3 + 3 + 3 + 3 = 12 + * - Edge ratio: 12 / 14 = 0.857... + * - Graph density would be: 6 / (4*3/2) = 6/6 = 1.0 + * - This discriminates: if cohesion < 1.0, it's edge ratio; if 1.0, it could be density. + */ + it('produces internal edge ratio, not graph density, for a tight cluster with external edges', async () => { + const graph = createKnowledgeGraph(); + + // Clique of 4 nodes + const clique = addClique(graph, 'c', 'cluster', 4); + + // Two external nodes, each connected to one clique member + graph.addNode(makeNode('fn:ext0', 'extFn0', 'Function', '/src/other/ext0.ts')); + graph.addNode(makeNode('fn:ext1', 'extFn1', 'Function', '/src/other/ext1.ts')); + // Connect ext nodes to each other so they form their own community (size >= 2) + graph.addRelationship(makeRel('rel:ext_link', 'fn:ext0', 'fn:ext1')); + // Boundary edges from clique to external + graph.addRelationship(makeRel('rel:boundary0', clique[0], 'fn:ext0')); + graph.addRelationship(makeRel('rel:boundary1', clique[1], 'fn:ext1')); + + const result = await processCommunities(graph); + + // Find the community containing the clique nodes + const cliqueMemberSet = new Set(clique); + const membershipMap = new Map<string, string>(); + for (const m of result.memberships) { + membershipMap.set(m.nodeId, m.communityId); + } + + // Determine which community the clique nodes belong to + const cliqueCommunityId = membershipMap.get(clique[0]); + expect(cliqueCommunityId).toBeDefined(); + + // All clique nodes should be in the same community + for (const nodeId of clique) { + expect(membershipMap.get(nodeId)).toBe(cliqueCommunityId); + } + + // Find the community node + const cliqueCommunity = result.communities.find(c => c.id === cliqueCommunityId); + expect(cliqueCommunity).toBeDefined(); + + // Key assertion: cohesion should be < 1.0 (edge ratio with boundary edges) + // Graph density would be 1.0 since 4 nodes are fully connected internally. + // Edge ratio: 12 internal traversals / 14 total traversals = ~0.857 + expect(cliqueCommunity!.cohesion).toBeLessThan(1.0); + expect(cliqueCommunity!.cohesion).toBeCloseTo(12 / 14, 2); + }); + + /** + * A fully isolated clique with no external edges. + * Both formulas agree: cohesion should be 1.0 because all edges are internal. + */ + it('cohesion is 1.0 when community has no external edges', async () => { + const graph = createKnowledgeGraph(); + + // Single isolated clique of 4 — no boundary edges at all + addClique(graph, 'iso', 'isolated', 4); + + const result = await processCommunities(graph); + + // Should produce exactly one community (singletons are filtered) + expect(result.communities.length).toBeGreaterThanOrEqual(1); + + // The community containing our clique should have cohesion 1.0 + const community = result.communities.find(c => c.symbolCount >= 4); + // If Leiden puts them all in one community (expected for a fully connected graph) + if (community) { + expect(community.cohesion).toBe(1.0); + } + }); + + /** + * Two variants of the same base clique: one with few external edges, + * one with many. The variant with more external edges should have lower cohesion. + */ + it('cohesion decreases as external edge proportion increases', async () => { + // --- Variant A: clique with 1 external edge --- + const graphA = createKnowledgeGraph(); + const cliqueA = addClique(graphA, 'a', 'groupA', 4); + // One external node pair (to form a valid community) + graphA.addNode(makeNode('fn:extA0', 'extA0', 'Function', '/src/extA/e0.ts')); + graphA.addNode(makeNode('fn:extA1', 'extA1', 'Function', '/src/extA/e1.ts')); + graphA.addRelationship(makeRel('rel:extA_link', 'fn:extA0', 'fn:extA1')); + // 1 boundary edge + graphA.addRelationship(makeRel('rel:bndA0', cliqueA[0], 'fn:extA0')); + + const resultA = await processCommunities(graphA); + const commIdA = resultA.memberships.find(m => m.nodeId === cliqueA[0])?.communityId; + const communityA = resultA.communities.find(c => c.id === commIdA); + + // --- Variant B: clique with 4 external edges --- + const graphB = createKnowledgeGraph(); + const cliqueB = addClique(graphB, 'b', 'groupB', 4); + // Four external nodes (two pairs) + for (let i = 0; i < 4; i++) { + graphB.addNode(makeNode(`fn:extB${i}`, `extB${i}`, 'Function', `/src/extB/e${i}.ts`)); + } + graphB.addRelationship(makeRel('rel:extB_link0', 'fn:extB0', 'fn:extB1')); + graphB.addRelationship(makeRel('rel:extB_link1', 'fn:extB2', 'fn:extB3')); + // 4 boundary edges (one per clique node) + for (let i = 0; i < 4; i++) { + graphB.addRelationship(makeRel(`rel:bndB${i}`, cliqueB[i], `fn:extB${i}`)); + } + + const resultB = await processCommunities(graphB); + const commIdB = resultB.memberships.find(m => m.nodeId === cliqueB[0])?.communityId; + const communityB = resultB.communities.find(c => c.id === commIdB); + + expect(communityA).toBeDefined(); + expect(communityB).toBeDefined(); + + // More external edges => lower cohesion + expect(communityB!.cohesion).toBeLessThan(communityA!.cohesion); + }); + + /** + * Edge case: a community with a single node should return cohesion 1.0. + * The code returns early for memberIds.length <= 1. + * Leiden skips singletons (communities with < 2 members), so we test this + * by building a graph where one node has no edges — it won't appear in a + * community at all. Instead, test with 2 connected nodes and verify the + * community gets cohesion 1.0 (2 nodes, 1 internal edge, 0 external = 1.0). + */ + it('two-node community with no external edges returns 1.0', async () => { + const graph = createKnowledgeGraph(); + graph.addNode(makeNode('fn:pair0', 'pairFn0', 'Function', '/src/pair/f0.ts')); + graph.addNode(makeNode('fn:pair1', 'pairFn1', 'Function', '/src/pair/f1.ts')); + graph.addRelationship(makeRel('rel:pair', 'fn:pair0', 'fn:pair1')); + + const result = await processCommunities(graph); + + // Should have exactly 1 community with 2 members + expect(result.communities).toHaveLength(1); + expect(result.communities[0].symbolCount).toBe(2); + expect(result.communities[0].cohesion).toBe(1.0); + }); + + /** + * Sanity check: an empty graph should yield no communities. + */ + it('empty graph returns empty communities', async () => { + const graph = createKnowledgeGraph(); + const result = await processCommunities(graph); + + expect(result.communities).toEqual([]); + expect(result.memberships).toEqual([]); + expect(result.stats.totalCommunities).toBe(0); + expect(result.stats.nodesProcessed).toBe(0); + }); + + /** + * Verify that the web and backend formulas produce equivalent results + * by checking the backend value against a hand-calculated edge-ratio result. + * + * Topology: 3-node triangle (clique) + 1 external node connected to one vertex. + * - Triangle: 3 internal edges + * - 1 boundary edge from vertex 0 to external node + * - Traversals from triangle members: + * vertex0: 2 internal neighbors + 1 external = 3 traversals + * vertex1: 2 internal neighbors = 2 traversals + * vertex2: 2 internal neighbors = 2 traversals + * - Total traversals: 7, internal traversals: 6 + * - Edge ratio: 6/7 ≈ 0.857 + * + * The external node is a singleton so Leiden won't produce a community for it. + * But we need at least 2 external nodes connected to each other for Leiden + * to form a second community. Let's add a second external node. + * - vertex0 connects to ext0, ext0 connects to ext1 + * - Triangle traversals: + * vertex0: 2 internal + 1 external = 3 + * vertex1: 2 internal = 2 + * vertex2: 2 internal = 2 + * - Total: 7, internal: 6, ratio: 6/7 ≈ 0.857 + */ + it('web and backend formulas produce equivalent edge-ratio results', async () => { + const graph = createKnowledgeGraph(); + + // Triangle clique + const tri = ['fn:t0', 'fn:t1', 'fn:t2']; + graph.addNode(makeNode('fn:t0', 'triFn0', 'Function', '/src/tri/f0.ts')); + graph.addNode(makeNode('fn:t1', 'triFn1', 'Function', '/src/tri/f1.ts')); + graph.addNode(makeNode('fn:t2', 'triFn2', 'Function', '/src/tri/f2.ts')); + graph.addRelationship(makeRel('rel:t01', 'fn:t0', 'fn:t1')); + graph.addRelationship(makeRel('rel:t02', 'fn:t0', 'fn:t2')); + graph.addRelationship(makeRel('rel:t12', 'fn:t1', 'fn:t2')); + + // External pair + graph.addNode(makeNode('fn:ext0', 'extFn0', 'Function', '/src/ext/e0.ts')); + graph.addNode(makeNode('fn:ext1', 'extFn1', 'Function', '/src/ext/e1.ts')); + graph.addRelationship(makeRel('rel:ext', 'fn:ext0', 'fn:ext1')); + + // Boundary edge: triangle vertex0 -> ext0 + graph.addRelationship(makeRel('rel:bnd', 'fn:t0', 'fn:ext0')); + + const result = await processCommunities(graph); + + // Find triangle community + const triCommId = result.memberships.find(m => m.nodeId === 'fn:t0')?.communityId; + expect(triCommId).toBeDefined(); + + const triComm = result.communities.find(c => c.id === triCommId); + expect(triComm).toBeDefined(); + + // Hand-calculated edge ratio: 6 internal traversals / 7 total = 0.8571... + const expectedEdgeRatio = 6 / 7; + expect(triComm!.cohesion).toBeCloseTo(expectedEdgeRatio, 2); + + // Verify it's NOT graph density (which would be 3 / (3*2/2) = 1.0) + expect(triComm!.cohesion).not.toBeCloseTo(1.0, 2); + }); +}); diff --git a/gitnexus/test/unit/community-processor.test.ts b/gitnexus/test/unit/community-processor.test.ts new file mode 100644 index 0000000000..b2310b6e14 --- /dev/null +++ b/gitnexus/test/unit/community-processor.test.ts @@ -0,0 +1,38 @@ +import { describe, it, expect } from 'vitest'; +import { getCommunityColor, COMMUNITY_COLORS } from '../../src/core/ingestion/community-processor.js'; + +describe('community-processor', () => { + describe('COMMUNITY_COLORS', () => { + it('has 12 colors', () => { + expect(COMMUNITY_COLORS).toHaveLength(12); + }); + + it('contains valid hex color strings', () => { + for (const color of COMMUNITY_COLORS) { + expect(color).toMatch(/^#[0-9a-fA-F]{6}$/); + } + }); + + it('has no duplicate colors', () => { + const unique = new Set(COMMUNITY_COLORS); + expect(unique.size).toBe(COMMUNITY_COLORS.length); + }); + }); + + describe('getCommunityColor', () => { + it('returns first color for index 0', () => { + expect(getCommunityColor(0)).toBe(COMMUNITY_COLORS[0]); + }); + + it('wraps around when index exceeds color count', () => { + expect(getCommunityColor(12)).toBe(COMMUNITY_COLORS[0]); + expect(getCommunityColor(13)).toBe(COMMUNITY_COLORS[1]); + }); + + it('returns different colors for different indices', () => { + const c0 = getCommunityColor(0); + const c1 = getCommunityColor(1); + expect(c0).not.toBe(c1); + }); + }); +}); diff --git a/gitnexus/test/unit/compatible-stdio-transport.test.ts b/gitnexus/test/unit/compatible-stdio-transport.test.ts new file mode 100644 index 0000000000..04c75a7b75 --- /dev/null +++ b/gitnexus/test/unit/compatible-stdio-transport.test.ts @@ -0,0 +1,259 @@ +import { PassThrough } from 'node:stream'; +import { beforeEach, describe, expect, it, vi } from 'vitest'; +import { CompatibleStdioServerTransport } from '../../src/mcp/compatible-stdio-transport.js'; + +function onceMessage(transport: CompatibleStdioServerTransport): Promise<any> { + return new Promise((resolve, reject) => { + transport.onmessage = (message) => resolve(message); + transport.onerror = (error) => reject(error); + }); +} + +describe('CompatibleStdioServerTransport', () => { + let stdin: PassThrough; + let stdout: PassThrough; + let transport: CompatibleStdioServerTransport; + + beforeEach(() => { + stdin = new PassThrough(); + stdout = new PassThrough(); + transport = new CompatibleStdioServerTransport(stdin, stdout); + }); + + it('parses Content-Length framed initialize requests', async () => { + await transport.start(); + const messagePromise = onceMessage(transport); + const body = JSON.stringify({ + jsonrpc: '2.0', + id: 1, + method: 'initialize', + params: { + protocolVersion: '2024-11-05', + capabilities: {}, + clientInfo: { name: 'codex', version: '0.1' }, + }, + }); + + stdin.write(`Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`); + + await expect(messagePromise).resolves.toMatchObject({ + method: 'initialize', + params: { clientInfo: { name: 'codex' } }, + }); + }); + + it('parses newline-delimited initialize requests', async () => { + await transport.start(); + const messagePromise = onceMessage(transport); + stdin.write(`${JSON.stringify({ + jsonrpc: '2.0', + id: 1, + method: 'initialize', + params: { + protocolVersion: '2024-11-05', + capabilities: {}, + clientInfo: { name: 'cursor', version: '0.1' }, + }, + })}\n`); + + await expect(messagePromise).resolves.toMatchObject({ + method: 'initialize', + params: { clientInfo: { name: 'cursor' } }, + }); + }); + + it('responds with Content-Length framing after Content-Length input', async () => { + await transport.start(); + const body = JSON.stringify({ + jsonrpc: '2.0', + id: 1, + method: 'initialize', + params: { + protocolVersion: '2024-11-05', + capabilities: {}, + clientInfo: { name: 'codex', version: '0.1' }, + }, + }); + + const messagePromise = onceMessage(transport); + stdin.write(`Content-Length: ${Buffer.byteLength(body, 'utf8')}\n\n${body}`); + await messagePromise; + + const chunks: Buffer[] = []; + stdout.on('data', (chunk) => chunks.push(Buffer.from(chunk))); + + await transport.send({ jsonrpc: '2.0', id: 1, result: { ok: true } }); + const raw = Buffer.concat(chunks).toString('utf8'); + + expect(raw).toMatch(/^Content-Length: \d+\r\n\r\n/); + expect(raw).toContain('"ok":true'); + }); + + + + it('reports malformed Content-Length headers once without looping forever', async () => { + await transport.start(); + const onError = vi.fn(); + transport.onerror = onError; + + stdin.write('Content-Length:\r\n\r\n{}'); + await new Promise((resolve) => setTimeout(resolve, 25)); + + expect(onError).toHaveBeenCalledTimes(1); + expect(onError.mock.calls[0]?.[0]).toBeInstanceOf(Error); + }); + + it('recovers after discarding a malformed Content-Length frame', async () => { + await transport.start(); + const onError = vi.fn(); + transport.onerror = onError; + + stdin.write('Content-Length:\r\n\r\n{}'); + await new Promise((resolve) => setTimeout(resolve, 25)); + + const body = JSON.stringify({ + jsonrpc: '2.0', + id: 2, + method: 'initialize', + params: { + protocolVersion: '2024-11-05', + capabilities: {}, + clientInfo: { name: 'recovery-client', version: '0.1' }, + }, + }); + const messagePromise = onceMessage(transport); + stdin.write(`Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`); + + await expect(messagePromise).resolves.toMatchObject({ + method: 'initialize', + params: { clientInfo: { name: 'recovery-client' } }, + }); + expect(onError).toHaveBeenCalledTimes(1); + }); + + // ─── Security hardening regressions ────────────────────────────── + + it('rejects Content-Length values exceeding the buffer cap', async () => { + await transport.start(); + const onError = vi.fn(); + transport.onerror = onError; + + // 20 MB — exceeds the 10 MB MAX_BUFFER_SIZE + stdin.write('Content-Length: 20971520\r\n\r\n{}'); + await new Promise((resolve) => setTimeout(resolve, 25)); + + expect(onError).toHaveBeenCalledTimes(1); + expect(onError.mock.calls[0]?.[0]?.message).toMatch(/exceeds maximum/i); + }); + + it('errors when read buffer exceeds maximum size in newline mode', async () => { + await transport.start(); + const onError = vi.fn(); + transport.onerror = onError; + + // Send a JSON-starting chunk (triggers newline mode) with no newline, + // then keep appending until we exceed the 10 MB cap + const chunkSize = 1024 * 1024; // 1 MB + const chunk = Buffer.alloc(chunkSize, 0x61); // 'a' repeated + // First byte must be '{' to trigger newline framing detection + const first = Buffer.from('{' + 'a'.repeat(chunkSize - 1)); + stdin.write(first); + + for (let i = 0; i < 10; i++) { + stdin.write(chunk); + } + + await new Promise((resolve) => setTimeout(resolve, 25)); + + expect(onError).toHaveBeenCalled(); + const hasMaxSizeError = onError.mock.calls.some( + (call) => call[0] instanceof Error && /maximum size/i.test(call[0].message), + ); + expect(hasMaxSizeError).toBe(true); + }); + + it('handles many consecutive empty lines without stack overflow', async () => { + await transport.start(); + const onError = vi.fn(); + transport.onerror = onError; + + // First, seed the framing mode with a valid newline-delimited message + const seed = JSON.stringify({ + jsonrpc: '2.0', + id: 1, + method: 'initialize', + params: { + protocolVersion: '2024-11-05', + capabilities: {}, + clientInfo: { name: 'seed', version: '0.1' }, + }, + }); + const seedPromise = onceMessage(transport); + stdin.write(seed + '\n'); + await seedPromise; + + // Now send 15K empty lines followed by a real message — this would + // stack-overflow with the old recursive readNewlineMessage + const followup = JSON.stringify({ + jsonrpc: '2.0', + id: 2, + method: 'notifications/initialized', + params: {}, + }); + + const messagePromise = onceMessage(transport); + stdin.write('\n'.repeat(15_000) + followup + '\n'); + + await expect(messagePromise).resolves.toMatchObject({ + method: 'notifications/initialized', + }); + expect(onError).not.toHaveBeenCalled(); + }); + + it('rejects send() after transport is closed', async () => { + await transport.start(); + await transport.close(); + + await expect( + transport.send({ jsonrpc: '2.0', id: 1, result: { ok: true } }), + ).rejects.toThrow(/closed/i); + }); + + it('does not detect content-length framing from short ambiguous prefix', async () => { + await transport.start(); + const onError = vi.fn(); + transport.onerror = onError; + + // Write only "cont" — fewer than 14 bytes, should NOT trigger + // content-length detection. Transport should wait for more data. + stdin.write(Buffer.from('cont')); + await new Promise((resolve) => setTimeout(resolve, 25)); + + // No message and no error — transport is waiting for more data + expect(onError).not.toHaveBeenCalled(); + }); + + it('responds with newline framing after newline input', async () => { + await transport.start(); + const messagePromise = onceMessage(transport); + stdin.write(`${JSON.stringify({ + jsonrpc: '2.0', + id: 1, + method: 'initialize', + params: { + protocolVersion: '2024-11-05', + capabilities: {}, + clientInfo: { name: 'cursor', version: '0.1' }, + }, + })}\n`); + await messagePromise; + + const chunks: Buffer[] = []; + stdout.on('data', (chunk) => chunks.push(Buffer.from(chunk))); + + await transport.send({ jsonrpc: '2.0', id: 1, result: { ok: true } }); + const raw = Buffer.concat(chunks).toString('utf8'); + + expect(raw).toBe('{"jsonrpc":"2.0","id":1,"result":{"ok":true}}\n'); + }); +}); diff --git a/gitnexus/test/unit/csv-escaping.test.ts b/gitnexus/test/unit/csv-escaping.test.ts new file mode 100644 index 0000000000..1e1892b84f --- /dev/null +++ b/gitnexus/test/unit/csv-escaping.test.ts @@ -0,0 +1,173 @@ +/** + * P0 Unit Tests: CSV Escaping Functions + * + * Tests: escapeCSVField, escapeCSVNumber, sanitizeUTF8, isBinaryContent + * Covers hardening fix #23 (keyword arrays with backslashes and commas) + */ +import { describe, it, expect } from 'vitest'; +import { + escapeCSVField, + escapeCSVNumber, + sanitizeUTF8, + isBinaryContent, +} from '../../src/core/lbug/csv-generator.js'; + +// ─── escapeCSVField ────────────────────────────────────────────────── + +describe('escapeCSVField', () => { + it('returns empty quoted string for null', () => { + expect(escapeCSVField(null)).toBe('""'); + }); + + it('returns empty quoted string for undefined', () => { + expect(escapeCSVField(undefined)).toBe('""'); + }); + + it('returns quoted empty string for empty input', () => { + expect(escapeCSVField('')).toBe('""'); + }); + + it('wraps simple string in quotes', () => { + expect(escapeCSVField('hello')).toBe('"hello"'); + }); + + it('doubles internal double quotes', () => { + expect(escapeCSVField('say "hello"')).toBe('"say ""hello"""'); + }); + + it('handles strings with commas', () => { + expect(escapeCSVField('a,b,c')).toBe('"a,b,c"'); + }); + + it('handles strings with newlines', () => { + expect(escapeCSVField('line1\nline2')).toBe('"line1\nline2"'); + }); + + it('converts numbers to quoted strings', () => { + expect(escapeCSVField(42)).toBe('"42"'); + }); + + it('handles strings with both quotes and commas', () => { + expect(escapeCSVField('"hello",world')).toBe('"""hello"",world"'); + }); + + // Hardening fix #23: keyword arrays with backslashes + it('handles strings with backslashes', () => { + const result = escapeCSVField('path\\to\\file'); + expect(result).toBe('"path\\to\\file"'); + }); + + it('handles code content with special characters', () => { + const code = 'function foo() {\n return "bar";\n}'; + const result = escapeCSVField(code); + expect(result).toContain('function foo()'); + expect(result).toContain('""bar""'); + }); +}); + +// ─── escapeCSVNumber ───────────────────────────────────────────────── + +describe('escapeCSVNumber', () => { + it('returns default value for null', () => { + expect(escapeCSVNumber(null)).toBe('-1'); + }); + + it('returns default value for undefined', () => { + expect(escapeCSVNumber(undefined)).toBe('-1'); + }); + + it('returns custom default value', () => { + expect(escapeCSVNumber(null, 0)).toBe('0'); + }); + + it('returns string representation of number', () => { + expect(escapeCSVNumber(42)).toBe('42'); + }); + + it('handles zero', () => { + expect(escapeCSVNumber(0)).toBe('0'); + }); + + it('handles negative numbers', () => { + expect(escapeCSVNumber(-5)).toBe('-5'); + }); + + it('handles floating point', () => { + expect(escapeCSVNumber(3.14)).toBe('3.14'); + }); +}); + +// ─── sanitizeUTF8 ──────────────────────────────────────────────────── + +describe('sanitizeUTF8', () => { + it('passes through clean strings unchanged', () => { + expect(sanitizeUTF8('hello world')).toBe('hello world'); + }); + + it('normalizes CRLF to LF', () => { + expect(sanitizeUTF8('line1\r\nline2')).toBe('line1\nline2'); + }); + + it('normalizes lone CR to LF', () => { + expect(sanitizeUTF8('line1\rline2')).toBe('line1\nline2'); + }); + + it('strips null bytes', () => { + expect(sanitizeUTF8('hello\x00world')).toBe('helloworld'); + }); + + it('strips control characters', () => { + expect(sanitizeUTF8('hello\x01\x02\x03world')).toBe('helloworld'); + }); + + it('preserves tabs', () => { + expect(sanitizeUTF8('hello\tworld')).toBe('hello\tworld'); + }); + + it('preserves newlines', () => { + expect(sanitizeUTF8('hello\nworld')).toBe('hello\nworld'); + }); + + it('strips lone surrogates', () => { + expect(sanitizeUTF8('hello\uD800world')).toBe('helloworld'); + }); + + it('strips BOM-like characters (FFFE/FFFF)', () => { + expect(sanitizeUTF8('hello\uFFFEworld')).toBe('helloworld'); + }); +}); + +// ─── isBinaryContent ───────────────────────────────────────────────── + +describe('isBinaryContent', () => { + it('returns false for empty string', () => { + expect(isBinaryContent('')).toBe(false); + }); + + it('returns false for normal text', () => { + expect(isBinaryContent('hello world\nline two')).toBe(false); + }); + + it('returns false for code content', () => { + const code = 'function foo() {\n return 42;\n}\n'; + expect(isBinaryContent(code)).toBe(false); + }); + + it('returns true when >10% non-printable characters', () => { + // Create a string that's ~20% null bytes + const binary = 'a'.repeat(80) + '\x00'.repeat(20); + expect(isBinaryContent(binary)).toBe(true); + }); + + it('returns false when just under 10% threshold', () => { + // 9% non-printable should not be binary + const borderline = 'a'.repeat(91) + '\x01'.repeat(9); + expect(isBinaryContent(borderline)).toBe(false); + }); + + it('only samples first 1000 characters', () => { + // Binary content past 1000 chars should be ignored + const text = 'a'.repeat(1000) + '\x00'.repeat(500); + expect(isBinaryContent(text)).toBe(false); + }); +}); diff --git a/gitnexus/test/unit/embedder.test.ts b/gitnexus/test/unit/embedder.test.ts new file mode 100644 index 0000000000..20eaf8c597 --- /dev/null +++ b/gitnexus/test/unit/embedder.test.ts @@ -0,0 +1,16 @@ +import { describe, it, expect } from 'vitest'; +import { getEmbeddingDims, isEmbedderReady } from '../../src/mcp/core/embedder.js'; + +describe('embedder', () => { + describe('getEmbeddingDims', () => { + it('returns 384 (MiniLM default)', () => { + expect(getEmbeddingDims()).toBe(384); + }); + }); + + describe('isEmbedderReady', () => { + it('returns false before initialization', () => { + expect(isEmbedderReady()).toBe(false); + }); + }); +}); diff --git a/gitnexus/test/unit/entry-point-scoring.test.ts b/gitnexus/test/unit/entry-point-scoring.test.ts new file mode 100644 index 0000000000..b53f1f8e5c --- /dev/null +++ b/gitnexus/test/unit/entry-point-scoring.test.ts @@ -0,0 +1,254 @@ +import { describe, it, expect } from 'vitest'; +import { calculateEntryPointScore, isTestFile, isUtilityFile } from '../../src/core/ingestion/entry-point-scoring.js'; + +describe('calculateEntryPointScore', () => { + describe('base scoring', () => { + it('returns 0 for functions with no outgoing calls', () => { + const result = calculateEntryPointScore('handler', 'typescript', true, 0, 0); + expect(result.score).toBe(0); + expect(result.reasons).toContain('no-outgoing-calls'); + }); + + it('calculates base score as calleeCount / (callerCount + 1)', () => { + const result = calculateEntryPointScore('doStuff', 'typescript', false, 0, 5); + // base = 5 / (0 + 1) = 5, no export bonus, no name bonus + expect(result.score).toBe(5); + }); + + it('reduces score for functions with many callers', () => { + const few = calculateEntryPointScore('doStuff', 'typescript', false, 1, 5); + const many = calculateEntryPointScore('doStuff', 'typescript', false, 10, 5); + expect(few.score).toBeGreaterThan(many.score); + }); + }); + + describe('export multiplier', () => { + it('applies 2.0 multiplier for exported functions', () => { + const exported = calculateEntryPointScore('doStuff', 'typescript', true, 0, 4); + const notExported = calculateEntryPointScore('doStuff', 'typescript', false, 0, 4); + expect(exported.score).toBe(notExported.score * 2); + expect(exported.reasons).toContain('exported'); + }); + + it('does not add exported reason when not exported', () => { + const result = calculateEntryPointScore('doStuff', 'typescript', false, 0, 4); + expect(result.reasons).not.toContain('exported'); + }); + }); + + describe('universal name patterns', () => { + it.each([ + 'main', 'init', 'bootstrap', 'start', 'run', 'setup', 'configure', + ])('recognizes "%s" as entry point pattern', (name) => { + const result = calculateEntryPointScore(name, 'typescript', false, 0, 3); + expect(result.reasons).toContain('entry-pattern'); + }); + + it.each([ + 'handleLogin', 'handleSubmit', 'onClick', 'onSubmit', + 'RequestHandler', 'UserController', + 'processPayment', 'executeQuery', 'performAction', + 'dispatchEvent', 'triggerAction', 'fireEvent', 'emitEvent', + ])('recognizes "%s" as entry point pattern', (name) => { + const result = calculateEntryPointScore(name, 'typescript', false, 0, 3); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('applies 1.5x name multiplier for entry patterns', () => { + const matching = calculateEntryPointScore('handleLogin', 'typescript', false, 0, 4); + const plain = calculateEntryPointScore('doStuff', 'typescript', false, 0, 4); + // matching gets 1.5x, plain gets 1.0x + expect(matching.score).toBe(plain.score * 1.5); + }); + }); + + describe('language-specific patterns', () => { + it('recognizes React hooks for TypeScript', () => { + const result = calculateEntryPointScore('useEffect', 'typescript', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes React hooks for JavaScript', () => { + const result = calculateEntryPointScore('useState', 'javascript', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes Python REST patterns', () => { + const result = calculateEntryPointScore('get_users', 'python', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes Java servlet patterns', () => { + const result = calculateEntryPointScore('doGet', 'java', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes Go handler patterns', () => { + const result = calculateEntryPointScore('NewServer', 'go', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes Rust entry patterns', () => { + const result = calculateEntryPointScore('handle_request', 'rust', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes Swift UIKit lifecycle', () => { + const result = calculateEntryPointScore('viewDidLoad', 'swift', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes Swift SwiftUI body', () => { + const result = calculateEntryPointScore('body', 'swift', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes PHP Laravel patterns', () => { + // __invoke starts with '_' which matches utility pattern first + const result = calculateEntryPointScore('handle', 'php', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes PHP RESTful resource methods', () => { + const result = calculateEntryPointScore('index', 'php', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes C# ASP.NET patterns', () => { + const result = calculateEntryPointScore('GetUsers', 'csharp', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + it('recognizes C main entry point', () => { + const result = calculateEntryPointScore('main', 'c', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + // C-specific patterns + it.each([ + 'init_server', 'server_init', 'start_server', 'handle_request', + 'signal_handler', 'event_callback', 'cmd_new_window', 'server_start', + 'client_connect', 'session_create', 'window_resize', + ])('recognizes C pattern "%s"', (name) => { + const result = calculateEntryPointScore(name, 'c', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + + // C++-specific patterns + it.each([ + 'CreateInstance', 'create_session', 'Run', 'run', 'Start', 'start', + 'OnEventReceived', 'on_click', + ])('recognizes C++ pattern "%s"', (name) => { + const result = calculateEntryPointScore(name, 'cpp', false, 0, 2); + expect(result.reasons).toContain('entry-pattern'); + }); + }); + + describe('utility pattern penalty', () => { + it.each([ + 'getUser', 'setName', 'isValid', 'hasPermission', 'canEdit', + 'formatDate', 'parseJSON', 'validateInput', + 'toString', 'fromJSON', 'encodeBase64', 'serializeData', + 'cloneDeep', 'mergeObjects', + ])('penalizes utility function "%s"', (name) => { + const result = calculateEntryPointScore(name, 'typescript', false, 0, 3); + expect(result.reasons).toContain('utility-pattern'); + // 0.3 multiplier + const plain = calculateEntryPointScore('doStuff', 'typescript', false, 0, 3); + expect(result.score).toBeLessThan(plain.score); + }); + + it('penalizes private-by-convention functions', () => { + const result = calculateEntryPointScore('_internal', 'typescript', false, 0, 3); + expect(result.reasons).toContain('utility-pattern'); + }); + }); + + describe('framework detection from path', () => { + it('boosts Next.js page entry points', () => { + const result = calculateEntryPointScore('render', 'typescript', true, 0, 3, 'pages/users.tsx'); + expect(result.reasons.some(r => r.includes('framework:'))).toBe(true); + expect(result.score).toBeGreaterThan(0); + }); + + it('does not apply framework bonus for non-framework paths', () => { + const result = calculateEntryPointScore('render', 'typescript', true, 0, 3, 'src/lib/utils.ts'); + expect(result.reasons.every(r => !r.includes('framework:'))).toBe(true); + }); + }); + + describe('combined scoring', () => { + it('multiplies all factors together', () => { + // handleLogin: entry pattern (1.5x) + exported (2.0x) + base + const result = calculateEntryPointScore('handleLogin', 'typescript', true, 0, 4, 'routes/auth.ts'); + expect(result.score).toBeGreaterThan(0); + expect(result.reasons).toContain('exported'); + expect(result.reasons).toContain('entry-pattern'); + }); + }); +}); + +describe('isTestFile', () => { + it.each([ + 'src/utils.test.ts', + 'src/utils.spec.ts', + '__tests__/utils.ts', + '__mocks__/api.ts', + 'src/test/integration/db.ts', + 'src/tests/unit/helper.ts', + 'src/testing/setup.ts', + 'lib/test_utils.py', + 'pkg/handler_test.go', + 'src/test/java/com/example/Test.java', + 'MyViewTests.swift', + 'MyViewTest.swift', + 'UITests/LoginTest.swift', + 'App.Tests/MyTest.cs', + 'tests/Feature/UserTest.php', + 'tests/Unit/AuthSpec.php', + ])('returns true for test file "%s"', (filePath) => { + expect(isTestFile(filePath)).toBe(true); + }); + + it.each([ + 'src/utils.ts', + 'src/controllers/auth.ts', + 'src/main.py', + 'cmd/server.go', + 'src/main/java/App.java', + ])('returns false for non-test file "%s"', (filePath) => { + expect(isTestFile(filePath)).toBe(false); + }); + + it('normalizes Windows backslashes', () => { + expect(isTestFile('src\\__tests__\\utils.ts')).toBe(true); + }); +}); + +describe('isUtilityFile', () => { + it.each([ + 'src/utils/format.ts', + 'src/util/helpers.ts', + 'src/helpers/date.ts', + 'src/helper/string.ts', + 'src/common/types.ts', + 'src/shared/constants.ts', + 'src/lib/crypto.ts', + 'src/utils.ts', + 'src/utils.js', + 'src/helpers.ts', + 'lib/date_utils.py', + 'lib/date_helpers.py', + ])('returns true for utility file "%s"', (filePath) => { + expect(isUtilityFile(filePath)).toBe(true); + }); + + it.each([ + 'src/controllers/auth.ts', + 'src/routes/api.ts', + 'src/main.ts', + 'src/app.ts', + ])('returns false for non-utility file "%s"', (filePath) => { + expect(isUtilityFile(filePath)).toBe(false); + }); +}); diff --git a/gitnexus/test/unit/eval-formatters.test.ts b/gitnexus/test/unit/eval-formatters.test.ts new file mode 100644 index 0000000000..4d288fcd4b --- /dev/null +++ b/gitnexus/test/unit/eval-formatters.test.ts @@ -0,0 +1,325 @@ +/** + * P1 Unit Tests: Eval Server Formatters + * + * Tests: formatQueryResult, formatContextResult, formatImpactResult, + * formatCypherResult, formatDetectChangesResult, formatListReposResult, MAX_BODY_SIZE + */ +import { describe, it, expect } from 'vitest'; +import { + formatQueryResult, + formatContextResult, + formatImpactResult, + formatCypherResult, + formatDetectChangesResult, + formatListReposResult, + MAX_BODY_SIZE, +} from '../../src/cli/eval-server.js'; + +// ─── MAX_BODY_SIZE ─────────────────────────────────────────────────── + +describe('MAX_BODY_SIZE', () => { + it('is 1MB', () => { + expect(MAX_BODY_SIZE).toBe(1024 * 1024); + }); +}); + +// ─── formatQueryResult ─────────────────────────────────────────────── + +describe('formatQueryResult', () => { + it('returns error message for error input', () => { + expect(formatQueryResult({ error: 'something failed' })).toBe('Error: something failed'); + }); + + it('returns no-match message for empty results', () => { + const result = formatQueryResult({ processes: [], definitions: [] }); + expect(result).toContain('No matching execution flows'); + }); + + it('formats processes with symbols', () => { + const result = formatQueryResult({ + processes: [ + { id: 'p1', summary: 'User Login Flow', step_count: 3, symbol_count: 2 }, + ], + process_symbols: [ + { process_id: 'p1', type: 'Function', name: 'login', filePath: 'src/auth.ts', startLine: 10 }, + { process_id: 'p1', type: 'Function', name: 'validate', filePath: 'src/auth.ts', startLine: 20 }, + ], + definitions: [], + }); + expect(result).toContain('1 execution flow'); + expect(result).toContain('User Login Flow'); + expect(result).toContain('login'); + expect(result).toContain(':10'); + }); + + it('truncates symbols per process at 6', () => { + const symbols = Array.from({ length: 10 }, (_, i) => ({ + process_id: 'p1', + type: 'Function', + name: `fn${i}`, + filePath: 'src/test.ts', + })); + const result = formatQueryResult({ + processes: [{ id: 'p1', summary: 'Flow', step_count: 10, symbol_count: 10 }], + process_symbols: symbols, + definitions: [], + }); + expect(result).toContain('and 4 more'); + }); + + it('formats standalone definitions', () => { + const result = formatQueryResult({ + processes: [], + definitions: [ + { type: 'Interface', name: 'Config', filePath: 'src/types.ts' }, + ], + }); + expect(result).toContain('Standalone definitions'); + expect(result).toContain('Config'); + }); + + it('truncates definitions at 8', () => { + const defs = Array.from({ length: 12 }, (_, i) => ({ + type: 'Interface', + name: `Type${i}`, + filePath: 'src/types.ts', + })); + const result = formatQueryResult({ processes: [], definitions: defs }); + expect(result).toContain('and 4 more'); + }); +}); + +// ─── formatContextResult ───────────────────────────────────────────── + +describe('formatContextResult', () => { + it('returns error message for error input', () => { + expect(formatContextResult({ error: 'not found' })).toBe('Error: not found'); + }); + + it('handles ambiguous results', () => { + const result = formatContextResult({ + status: 'ambiguous', + candidates: [ + { name: 'foo', kind: 'Function', filePath: 'src/a.ts', line: 10, uid: 'uid1' }, + { name: 'foo', kind: 'Function', filePath: 'src/b.ts', line: 5, uid: 'uid2' }, + ], + }); + expect(result).toContain('Multiple symbols'); + expect(result).toContain('uid1'); + expect(result).toContain('uid2'); + }); + + it('returns "Symbol not found" when no symbol', () => { + expect(formatContextResult({})).toBe('Symbol not found.'); + }); + + it('formats symbol with incoming/outgoing refs', () => { + const result = formatContextResult({ + symbol: { kind: 'Function', name: 'foo', filePath: 'src/a.ts', startLine: 1, endLine: 10 }, + incoming: { + CALLS: [{ kind: 'Function', name: 'bar', filePath: 'src/b.ts' }], + }, + outgoing: { + IMPORTS: [{ kind: 'Module', name: 'utils', filePath: 'src/utils.ts' }], + }, + processes: [], + }); + expect(result).toContain('Function foo'); + expect(result).toContain('Called/imported by (1)'); + expect(result).toContain('Calls/imports (1)'); + }); + + it('formats process participation', () => { + const result = formatContextResult({ + symbol: { kind: 'Function', name: 'foo', filePath: 'src/a.ts' }, + incoming: {}, + outgoing: {}, + processes: [ + { name: 'Auth Flow', step_index: 2, step_count: 5 }, + ], + }); + expect(result).toContain('1 execution flow'); + expect(result).toContain('Auth Flow'); + }); +}); + +// ─── formatImpactResult ────────────────────────────────────────────── + +describe('formatImpactResult', () => { + it('returns error message for error input', () => { + expect(formatImpactResult({ error: 'bad request' })).toContain('Error: bad request'); + }); + + it('returns error with suggestion when provided', () => { + const result = formatImpactResult({ + error: 'Impact analysis failed', + suggestion: 'Try gitnexus context <symbol> as a fallback', + }); + expect(result).toContain('Error: Impact analysis failed'); + expect(result).toContain('Suggestion: Try gitnexus context'); + }); + + it('shows partial warning when traversal was interrupted', () => { + const result = formatImpactResult({ + target: { kind: 'Function', name: 'foo' }, + direction: 'upstream', + impactedCount: 2, + partial: true, + byDepth: { + 1: [ + { type: 'Function', name: 'caller1', filePath: 'src/a.ts', relationType: 'CALLS', confidence: 1 }, + { type: 'Function', name: 'caller2', filePath: 'src/b.ts', relationType: 'CALLS', confidence: 1 }, + ], + }, + }); + expect(result).toContain('Partial results'); + expect(result).toContain('caller1'); + expect(result).toContain('caller2'); + }); + + it('handles zero impact', () => { + const result = formatImpactResult({ + target: { name: 'foo' }, + direction: 'upstream', + impactedCount: 0, + byDepth: {}, + }); + expect(result).toContain('No upstream dependencies'); + }); + + it('formats impact by depth', () => { + const result = formatImpactResult({ + target: { kind: 'Function', name: 'foo' }, + direction: 'upstream', + impactedCount: 3, + byDepth: { + 1: [ + { type: 'Function', name: 'caller1', filePath: 'src/a.ts', relationType: 'CALLS', confidence: 1 }, + { type: 'Function', name: 'caller2', filePath: 'src/b.ts', relationType: 'CALLS', confidence: 0.8 }, + ], + 2: [ + { type: 'Class', name: 'App', filePath: 'src/app.ts', relationType: 'IMPORTS', confidence: 1 }, + ], + }, + }); + expect(result).toContain('Blast radius'); + expect(result).toContain('WILL BREAK'); + expect(result).toContain('caller1'); + expect(result).toContain('conf: 0.8'); + expect(result).toContain('LIKELY AFFECTED'); + }); + + it('truncates items per depth at 12', () => { + const items = Array.from({ length: 15 }, (_, i) => ({ + type: 'Function', + name: `fn${i}`, + filePath: 'src/test.ts', + relationType: 'CALLS', + confidence: 1, + })); + const result = formatImpactResult({ + target: { kind: 'Function', name: 'foo' }, + direction: 'upstream', + impactedCount: 15, + byDepth: { 1: items }, + }); + expect(result).toContain('and 3 more'); + }); +}); + +// ─── formatCypherResult ────────────────────────────────────────────── + +describe('formatCypherResult', () => { + it('returns error message for error input', () => { + expect(formatCypherResult({ error: 'syntax error' })).toBe('Error: syntax error'); + }); + + it('handles empty array', () => { + expect(formatCypherResult([])).toBe('Query returned 0 rows.'); + }); + + it('formats array of objects as table', () => { + const result = formatCypherResult([ + { name: 'foo', filePath: 'src/a.ts' }, + { name: 'bar', filePath: 'src/b.ts' }, + ]); + expect(result).toContain('2 row(s)'); + expect(result).toContain('name: foo'); + expect(result).toContain('name: bar'); + }); + + it('truncates at 30 rows', () => { + const rows = Array.from({ length: 35 }, (_, i) => ({ id: i })); + const result = formatCypherResult(rows); + expect(result).toContain('5 more rows'); + }); + + it('handles string result', () => { + expect(formatCypherResult('some text')).toBe('some text'); + }); +}); + +// ─── formatDetectChangesResult ─────────────────────────────────────── + +describe('formatDetectChangesResult', () => { + it('returns error message for error input', () => { + expect(formatDetectChangesResult({ error: 'git error' })).toBe('Error: git error'); + }); + + it('handles no changes', () => { + const result = formatDetectChangesResult({ summary: { changed_count: 0 } }); + expect(result).toBe('No changes detected.'); + }); + + it('formats changes with affected processes', () => { + const result = formatDetectChangesResult({ + summary: { changed_files: 2, changed_count: 3, affected_count: 1, risk_level: 'MEDIUM' }, + changed_symbols: [ + { type: 'Function', name: 'foo', filePath: 'src/a.ts' }, + ], + affected_processes: [ + { name: 'Auth Flow', step_count: 5, changed_steps: [{ symbol: 'foo' }] }, + ], + }); + expect(result).toContain('2 files'); + expect(result).toContain('MEDIUM'); + expect(result).toContain('Auth Flow'); + }); + + it('truncates changed symbols at 15', () => { + const symbols = Array.from({ length: 20 }, (_, i) => ({ + type: 'Function', + name: `fn${i}`, + filePath: 'src/test.ts', + })); + const result = formatDetectChangesResult({ + summary: { changed_files: 1, changed_count: 20, affected_count: 0, risk_level: 'HIGH' }, + changed_symbols: symbols, + affected_processes: [], + }); + expect(result).toContain('and 5 more'); + }); +}); + +// ─── formatListReposResult ─────────────────────────────────────────── + +describe('formatListReposResult', () => { + it('handles empty/null input', () => { + expect(formatListReposResult([])).toBe('No indexed repositories.'); + expect(formatListReposResult(null)).toBe('No indexed repositories.'); + }); + + it('formats repo list', () => { + const result = formatListReposResult([ + { + name: 'my-project', + path: '/home/user/my-project', + indexedAt: '2024-01-01', + stats: { nodes: 100, edges: 200, processes: 10 }, + }, + ]); + expect(result).toContain('Indexed repositories'); + expect(result).toContain('my-project'); + expect(result).toContain('100 symbols'); + }); +}); diff --git a/gitnexus/test/unit/extract-element-type-from-string.test.ts b/gitnexus/test/unit/extract-element-type-from-string.test.ts new file mode 100644 index 0000000000..4d642428ed --- /dev/null +++ b/gitnexus/test/unit/extract-element-type-from-string.test.ts @@ -0,0 +1,165 @@ +import { describe, it, expect } from 'vitest'; +import { extractElementTypeFromString } from '../../src/core/ingestion/type-extractors/shared.js'; + +describe('extractElementTypeFromString', () => { + describe('array suffix (TypeScript / Java / C#)', () => { + it('User[] → User', () => { + expect(extractElementTypeFromString('User[]')).toBe('User'); + }); + + it('string[] → string', () => { + expect(extractElementTypeFromString('string[]')).toBe('string'); + }); + + it('int[] → int', () => { + expect(extractElementTypeFromString('int[]')).toBe('int'); + }); + }); + + describe('Go slice prefix', () => { + it('[]User → User', () => { + expect(extractElementTypeFromString('[]User')).toBe('User'); + }); + + it('[]string → string', () => { + expect(extractElementTypeFromString('[]string')).toBe('string'); + }); + }); + + describe('Swift array sugar', () => { + it('[User] → User', () => { + expect(extractElementTypeFromString('[User]')).toBe('User'); + }); + + it('[String] → String', () => { + expect(extractElementTypeFromString('[String]')).toBe('String'); + }); + }); + + describe('generic angle-bracket containers', () => { + it('Array<User> → User', () => { + expect(extractElementTypeFromString('Array<User>')).toBe('User'); + }); + + it('Vec<User> → User (Rust)', () => { + expect(extractElementTypeFromString('Vec<User>')).toBe('User'); + }); + + it('vector<User> → User (C++)', () => { + expect(extractElementTypeFromString('vector<User>')).toBe('User'); + }); + + it('Set<User> → User', () => { + expect(extractElementTypeFromString('Set<User>')).toBe('User'); + }); + + it('List<User> → User', () => { + expect(extractElementTypeFromString('List<User>')).toBe('User'); + }); + + it('IEnumerable<User> → User (C#)', () => { + expect(extractElementTypeFromString('IEnumerable<User>')).toBe('User'); + }); + }); + + describe('Python subscript-style generics', () => { + it('List[User] → User', () => { + expect(extractElementTypeFromString('List[User]')).toBe('User'); + }); + + it('Set[User] → User', () => { + expect(extractElementTypeFromString('Set[User]')).toBe('User'); + }); + }); + + describe('multi-argument generics — default returns last (value) arg', () => { + it('Map<String, User> → User (default: last/value arg)', () => { + expect(extractElementTypeFromString('Map<String, User>')).toBe('User'); + }); + + it('Map<String, User> → String (pos=first: key arg)', () => { + expect(extractElementTypeFromString('Map<String, User>', 'first')).toBe('String'); + }); + + it('Map<String, List<User>> → undefined (last arg is nested generic)', () => { + expect(extractElementTypeFromString('Map<String, List<User>>')).toBeUndefined(); + }); + + it('Map<String, List<User>> → String (pos=first: key arg)', () => { + expect(extractElementTypeFromString('Map<String, List<User>>', 'first')).toBe('String'); + }); + + it('Dict[str, User] → User (default: last/value arg, Python)', () => { + expect(extractElementTypeFromString('Dict[str, User]')).toBe('User'); + }); + + it('Dict[str, User] → str (pos=first: key arg, Python)', () => { + expect(extractElementTypeFromString('Dict[str, User]', 'first')).toBe('str'); + }); + }); + + describe('nested generics as element type — returns undefined', () => { + it('Array<List<User>> → undefined (element is itself generic)', () => { + // The element "List<User>" is not a plain word, so return undefined. + expect(extractElementTypeFromString('Array<List<User>>')).toBeUndefined(); + }); + + it('Vec<Option<User>> → undefined (element is itself generic)', () => { + expect(extractElementTypeFromString('Vec<Option<User>>')).toBeUndefined(); + }); + }); + + describe('cross-bracket nesting (bracket depth fix)', () => { + it('Dict[str, List[int]] → undefined (default: last arg is nested generic)', () => { + expect(extractElementTypeFromString('Dict[str, List[int]]')).toBeUndefined(); + }); + + it('Dict[str, List[int]] → str (pos=first: key arg)', () => { + expect(extractElementTypeFromString('Dict[str, List[int]]', 'first')).toBe('str'); + }); + + it('Map<String, List<User>> → undefined (default: last arg is nested generic)', () => { + expect(extractElementTypeFromString('Map<String, List<User>>')).toBeUndefined(); + }); + + it('Map<String, List<User>> → String (pos=first: key arg)', () => { + expect(extractElementTypeFromString('Map<String, List<User>>', 'first')).toBe('String'); + }); + + it('mismatched close bracket at depth 0 → undefined', () => { + // openChar is '<' but first close at depth 0 is ']' — malformed + expect(extractElementTypeFromString('Array<int]')).toBeUndefined(); + }); + }); + + describe('edge cases — return undefined', () => { + it('empty string → undefined', () => { + expect(extractElementTypeFromString('')).toBeUndefined(); + }); + + it('plain type name (no container) → undefined', () => { + expect(extractElementTypeFromString('User')).toBeUndefined(); + }); + + it('bare angle bracket with no close → undefined (malformed)', () => { + expect(extractElementTypeFromString('Array<User')).toBeUndefined(); + }); + + it('bare [] prefix with spaces only → undefined', () => { + expect(extractElementTypeFromString('[]')).toBeUndefined(); + }); + + it('empty array suffix → undefined', () => { + expect(extractElementTypeFromString('[]')).toBeUndefined(); + }); + + it('[] suffix with no base → undefined', () => { + expect(extractElementTypeFromString('[]')).toBeUndefined(); + }); + + it('empty Swift sugar [] → undefined', () => { + // starts with '[' and ends with ']' but inner is empty + expect(extractElementTypeFromString('[ ]')).toBeUndefined(); + }); + }); +}); diff --git a/gitnexus/test/unit/extract-generic-type-args.test.ts b/gitnexus/test/unit/extract-generic-type-args.test.ts new file mode 100644 index 0000000000..1c994ee12e --- /dev/null +++ b/gitnexus/test/unit/extract-generic-type-args.test.ts @@ -0,0 +1,219 @@ +import { describe, it, expect } from 'vitest'; +import { extractGenericTypeArgs } from '../../src/core/ingestion/type-extractors/shared.js'; +import type { SyntaxNode } from '../../src/core/ingestion/utils.js'; + +/** + * Create a minimal mock SyntaxNode for testing type extraction. + * Only the properties used by extractSimpleTypeName / extractGenericTypeArgs + * are populated — everything else is left as stubs. + */ +function mockNode( + type: string, + opts: { + text?: string; + namedChildren?: SyntaxNode[]; + fields?: Record<string, SyntaxNode>; + } = {}, +): SyntaxNode { + const children = opts.namedChildren ?? []; + const fields = opts.fields ?? {}; + const text = opts.text ?? children.map((c) => c.text).join(', '); + + return { + type, + text, + namedChildCount: children.length, + namedChild: (i: number) => children[i] ?? null, + firstNamedChild: children[0] ?? null, + lastNamedChild: children[children.length - 1] ?? null, + childForFieldName: (name: string) => fields[name] ?? null, + } as unknown as SyntaxNode; +} + +// Helper: build a generic_type node with type_arguments +function genericType( + baseName: string, + typeArgNames: string[], + opts?: { argsNodeType?: string; wrapInProjection?: boolean }, +): SyntaxNode { + const argsNodeType = opts?.argsNodeType ?? 'type_arguments'; + + const baseNode = mockNode('type_identifier', { text: baseName }); + + let argChildren = typeArgNames.map((name) => + mockNode('type_identifier', { text: name }), + ); + + // Kotlin wraps each arg in type_projection > user_type > type_identifier + if (opts?.wrapInProjection) { + argChildren = typeArgNames.map((name) => { + const typeId = mockNode('type_identifier', { text: name }); + const userType = mockNode('user_type', { namedChildren: [typeId] }); + return mockNode('type_projection', { namedChildren: [userType] }); + }) as unknown as SyntaxNode[]; + } + + const typeArgsNode = mockNode(argsNodeType, { + namedChildren: argChildren, + }); + + return mockNode('generic_type', { + namedChildren: [baseNode, typeArgsNode], + fields: { name: baseNode }, + }); +} + +describe('extractGenericTypeArgs', () => { + describe('single type argument', () => { + it('extracts from TypeScript Array<User>', () => { + const node = genericType('Array', ['User']); + expect(extractGenericTypeArgs(node)).toEqual(['User']); + }); + + it('extracts from Java List<User>', () => { + const node = genericType('List', ['User']); + expect(extractGenericTypeArgs(node)).toEqual(['User']); + }); + + it('extracts from Rust Vec<User>', () => { + const node = genericType('Vec', ['User']); + expect(extractGenericTypeArgs(node)).toEqual(['User']); + }); + + it('extracts from C# List<User> (type_argument_list)', () => { + const node = genericType('List', ['User'], { + argsNodeType: 'type_argument_list', + }); + expect(extractGenericTypeArgs(node)).toEqual(['User']); + }); + }); + + describe('multiple type arguments', () => { + it('extracts from Java Map<String, User>', () => { + const node = genericType('Map', ['String', 'User']); + expect(extractGenericTypeArgs(node)).toEqual(['String', 'User']); + }); + + it('extracts from TS Map<string, number>', () => { + const node = genericType('Map', ['string', 'number']); + expect(extractGenericTypeArgs(node)).toEqual(['string', 'number']); + }); + }); + + describe('Kotlin type_projection wrapping', () => { + it('extracts from Kotlin List<User> through type_projection', () => { + const node = genericType('List', ['User'], { wrapInProjection: true }); + expect(extractGenericTypeArgs(node)).toEqual(['User']); + }); + + it('extracts from Kotlin Map<String, User> through type_projection', () => { + const node = genericType('Map', ['String', 'User'], { + wrapInProjection: true, + }); + expect(extractGenericTypeArgs(node)).toEqual(['String', 'User']); + }); + }); + + describe('parameterized_type (Java/Kotlin alternate node type)', () => { + it('extracts type arguments from parameterized_type', () => { + const baseNode = mockNode('type_identifier', { text: 'List' }); + const argNode = mockNode('type_identifier', { text: 'User' }); + const typeArgsNode = mockNode('type_arguments', { + namedChildren: [argNode], + }); + const node = mockNode('parameterized_type', { + namedChildren: [baseNode, typeArgsNode], + fields: { name: baseNode }, + }); + expect(extractGenericTypeArgs(node)).toEqual(['User']); + }); + }); + + describe('wrapper node unwrapping', () => { + it('unwraps type_annotation before extracting', () => { + const inner = genericType('Array', ['User']); + const wrapper = mockNode('type_annotation', { namedChildren: [inner] }); + expect(extractGenericTypeArgs(wrapper)).toEqual(['User']); + }); + + it('unwraps nullable_type before extracting', () => { + const inner = genericType('List', ['User']); + const wrapper = mockNode('nullable_type', { namedChildren: [inner] }); + expect(extractGenericTypeArgs(wrapper)).toEqual(['User']); + }); + + it('unwraps user_type before extracting (Kotlin)', () => { + const inner = genericType('MutableList', ['String']); + const wrapper = mockNode('user_type', { namedChildren: [inner] }); + expect(extractGenericTypeArgs(wrapper)).toEqual(['String']); + }); + }); + + describe('non-generic types return empty array', () => { + it('returns [] for plain type_identifier', () => { + const node = mockNode('type_identifier', { text: 'User' }); + expect(extractGenericTypeArgs(node)).toEqual([]); + }); + + it('returns [] for identifier', () => { + const node = mockNode('identifier', { text: 'foo' }); + expect(extractGenericTypeArgs(node)).toEqual([]); + }); + + it('returns [] for union_type', () => { + const node = mockNode('union_type', { + namedChildren: [ + mockNode('type_identifier', { text: 'string' }), + mockNode('type_identifier', { text: 'number' }), + ], + }); + expect(extractGenericTypeArgs(node)).toEqual([]); + }); + }); + + describe('nested generic types as arguments', () => { + it('extracts outer type arg names for nested generics', () => { + // Map<String, List<User>> — the second arg is itself a generic_type + // extractGenericTypeArgs should extract 'List' (via extractSimpleTypeName) + const innerGeneric = genericType('List', ['User']); + const stringNode = mockNode('type_identifier', { text: 'String' }); + const typeArgsNode = mockNode('type_arguments', { + namedChildren: [stringNode, innerGeneric], + }); + const baseNode = mockNode('type_identifier', { text: 'Map' }); + const node = mockNode('generic_type', { + namedChildren: [baseNode, typeArgsNode], + fields: { name: baseNode }, + }); + + // extractSimpleTypeName on a generic_type returns the base name + expect(extractGenericTypeArgs(node)).toEqual(['String', 'List']); + }); + }); + + describe('edge cases', () => { + it('returns [] for generic_type with no type_arguments child', () => { + const baseNode = mockNode('type_identifier', { text: 'List' }); + const node = mockNode('generic_type', { + namedChildren: [baseNode], + fields: { name: baseNode }, + }); + expect(extractGenericTypeArgs(node)).toEqual([]); + }); + + it('skips unresolvable type arguments', () => { + // If a child can't be resolved by extractSimpleTypeName, it is omitted + const baseNode = mockNode('type_identifier', { text: 'Fn' }); + const unresolvedArg = mockNode('function_type', { text: '() => void' }); + const resolvedArg = mockNode('type_identifier', { text: 'User' }); + const typeArgsNode = mockNode('type_arguments', { + namedChildren: [unresolvedArg, resolvedArg], + }); + const node = mockNode('generic_type', { + namedChildren: [baseNode, typeArgsNode], + fields: { name: baseNode }, + }); + expect(extractGenericTypeArgs(node)).toEqual(['User']); + }); + }); +}); diff --git a/gitnexus/test/unit/framework-detection.test.ts b/gitnexus/test/unit/framework-detection.test.ts new file mode 100644 index 0000000000..e81aed1c6d --- /dev/null +++ b/gitnexus/test/unit/framework-detection.test.ts @@ -0,0 +1,324 @@ +import { describe, it, expect } from 'vitest'; +import { detectFrameworkFromPath, detectFrameworkFromAST, FRAMEWORK_AST_PATTERNS } from '../../src/core/ingestion/framework-detection.js'; + +describe('detectFrameworkFromPath', () => { + describe('Next.js', () => { + it('detects Pages Router pages', () => { + const result = detectFrameworkFromPath('pages/users.tsx'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('nextjs-pages'); + expect(result!.entryPointMultiplier).toBe(3.0); + }); + + it('ignores _app and _document pages', () => { + expect(detectFrameworkFromPath('pages/_app.tsx')).toBeNull(); + }); + + it('detects App Router page.tsx', () => { + const result = detectFrameworkFromPath('app/dashboard/page.tsx'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('nextjs-app'); + }); + + it('detects API routes in pages', () => { + const result = detectFrameworkFromPath('pages/api/users.ts'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('nextjs-api'); + }); + + it('detects App Router API route.ts', () => { + const result = detectFrameworkFromPath('app/api/users/route.ts'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('nextjs-api'); + }); + + it('detects layout files', () => { + const result = detectFrameworkFromPath('app/layout.tsx'); + expect(result).not.toBeNull(); + expect(result!.entryPointMultiplier).toBe(2.0); + }); + }); + + describe('Express / Node.js', () => { + it('detects route files', () => { + const result = detectFrameworkFromPath('routes/auth.ts'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('express'); + expect(result!.entryPointMultiplier).toBe(2.5); + }); + }); + + describe('MVC controllers', () => { + it('detects controller folder', () => { + const result = detectFrameworkFromPath('controllers/UserController.ts'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('mvc'); + }); + + it('detects handlers folder', () => { + const result = detectFrameworkFromPath('handlers/auth.ts'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('handlers'); + }); + }); + + describe('React', () => { + it('has React component detection rule for views/components folders', () => { + // Note: The current implementation lowercases the path before checking + // PascalCase, so PascalCase detection currently can't match. + // This test documents the current behavior. + const result = detectFrameworkFromPath('views/Button.tsx'); + // Returns null because path is lowercased before PascalCase regex check + expect(result).toBeNull(); + }); + }); + + describe('Python frameworks', () => { + it('detects Django views', () => { + const result = detectFrameworkFromPath('myapp/views.py'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('django'); + expect(result!.entryPointMultiplier).toBe(3.0); + }); + + it('detects Django URLs', () => { + const result = detectFrameworkFromPath('myapp/urls.py'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('django'); + }); + + it('detects FastAPI routers', () => { + const result = detectFrameworkFromPath('routers/users.py'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('fastapi'); + }); + }); + + describe('Java frameworks', () => { + it('detects Spring controllers folder', () => { + const result = detectFrameworkFromPath('controller/UserController.java'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('spring'); + }); + + it('detects Spring controller by filename', () => { + const result = detectFrameworkFromPath('src/UserController.java'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('spring'); + }); + + it('detects Java service layer', () => { + const result = detectFrameworkFromPath('service/UserService.java'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('java-service'); + }); + }); + + describe('C# / .NET', () => { + it('detects ASP.NET controllers', () => { + const result = detectFrameworkFromPath('controllers/UsersController.cs'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('aspnet'); + }); + + it('detects Blazor pages', () => { + const result = detectFrameworkFromPath('pages/Index.razor'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('blazor'); + }); + }); + + describe('Go frameworks', () => { + it('detects Go handlers', () => { + const result = detectFrameworkFromPath('handlers/user.go'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('go-http'); + }); + + it('detects Go main.go', () => { + const result = detectFrameworkFromPath('cmd/server/main.go'); + expect(result).not.toBeNull(); + expect(result!.entryPointMultiplier).toBe(3.0); + }); + }); + + describe('Rust frameworks', () => { + it('detects Rust handlers', () => { + const result = detectFrameworkFromPath('handlers/auth.rs'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('rust-web'); + }); + + it('detects main.rs', () => { + const result = detectFrameworkFromPath('src/main.rs'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('rust'); + expect(result!.entryPointMultiplier).toBe(3.0); + }); + + it('detects bin folder', () => { + const result = detectFrameworkFromPath('src/bin/cli.rs'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('rust'); + }); + }); + + describe('C / C++', () => { + it('detects main.c', () => { + const result = detectFrameworkFromPath('src/main.c'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('c-cpp'); + }); + + it('detects main.cpp', () => { + const result = detectFrameworkFromPath('src/main.cpp'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('c-cpp'); + }); + }); + + describe('PHP / Laravel', () => { + it('detects Laravel routes', () => { + const result = detectFrameworkFromPath('routes/web.php'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('laravel'); + expect(result!.entryPointMultiplier).toBe(3.0); + }); + + it('detects Laravel controllers', () => { + const result = detectFrameworkFromPath('http/controllers/UserController.php'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('laravel'); + }); + + it('detects Laravel jobs', () => { + const result = detectFrameworkFromPath('jobs/SendEmail.php'); + expect(result).not.toBeNull(); + expect(result!.reason).toBe('laravel-job'); + }); + + it('detects Laravel middleware', () => { + const result = detectFrameworkFromPath('http/middleware/Auth.php'); + expect(result).not.toBeNull(); + expect(result!.reason).toBe('laravel-middleware'); + }); + + it('detects Laravel models', () => { + const result = detectFrameworkFromPath('models/User.php'); + expect(result).not.toBeNull(); + expect(result!.entryPointMultiplier).toBe(1.5); + }); + }); + + describe('Swift / iOS', () => { + it('detects AppDelegate', () => { + const result = detectFrameworkFromPath('Sources/AppDelegate.swift'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('ios'); + }); + + it('detects ViewControllers folder', () => { + const result = detectFrameworkFromPath('ViewControllers/LoginVC.swift'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('uikit'); + }); + + it('detects Coordinator pattern', () => { + const result = detectFrameworkFromPath('Coordinators/AppCoordinator.swift'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('ios-coordinator'); + }); + + it('detects SwiftUI views folder', () => { + const result = detectFrameworkFromPath('views/ContentView.swift'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('swiftui'); + }); + }); + + describe('generic patterns', () => { + it('returns null for unknown paths', () => { + expect(detectFrameworkFromPath('src/internal/crypto.ts')).toBeNull(); + }); + + it('normalizes Windows backslashes', () => { + const result = detectFrameworkFromPath('routes\\auth.ts'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('express'); + }); + }); +}); + +describe('detectFrameworkFromAST', () => { + it('returns null for empty inputs', () => { + expect(detectFrameworkFromAST('', '')).toBeNull(); + expect(detectFrameworkFromAST('typescript', '')).toBeNull(); + expect(detectFrameworkFromAST('', 'some code')).toBeNull(); + }); + + it('detects NestJS decorators in TypeScript', () => { + const result = detectFrameworkFromAST('typescript', '@Controller("/users")'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('nestjs'); + expect(result!.entryPointMultiplier).toBe(3.2); + }); + + it('detects NestJS decorators in JavaScript', () => { + const result = detectFrameworkFromAST('javascript', '@Get("/")'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('nestjs'); + }); + + it('detects FastAPI decorators in Python', () => { + const result = detectFrameworkFromAST('python', '@app.get("/users")'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('fastapi'); + }); + + it('detects Flask decorators in Python', () => { + const result = detectFrameworkFromAST('python', '@app.route("/users")'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('flask'); + }); + + it('detects Spring annotations in Java', () => { + const result = detectFrameworkFromAST('java', '@RestController'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('spring'); + }); + + it('detects ASP.NET attributes in C#', () => { + const result = detectFrameworkFromAST('csharp', '[ApiController]'); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('aspnet'); + }); + + it('detects Laravel route definitions in PHP', () => { + const result = detectFrameworkFromAST('php', "Route::get('/users', [UserController::class, 'index'])"); + expect(result).not.toBeNull(); + expect(result!.framework).toBe('laravel'); + }); + + it('returns null for unsupported language', () => { + expect(detectFrameworkFromAST('rust', '#[get("/")]')).toBeNull(); + }); + + it('is case-insensitive', () => { + const result = detectFrameworkFromAST('TypeScript', '@controller("/")'); + expect(result).not.toBeNull(); + }); +}); + +describe('FRAMEWORK_AST_PATTERNS', () => { + it('has patterns for all expected frameworks', () => { + const expectedFrameworks = [ + 'nestjs', 'express', 'fastapi', 'flask', 'spring', 'jaxrs', + 'aspnet', 'go-http', 'laravel', 'actix', 'axum', 'rocket', + 'uikit', 'swiftui', 'combine', + ]; + for (const fw of expectedFrameworks) { + expect(FRAMEWORK_AST_PATTERNS).toHaveProperty(fw); + expect(FRAMEWORK_AST_PATTERNS[fw as keyof typeof FRAMEWORK_AST_PATTERNS].length).toBeGreaterThan(0); + } + }); +}); diff --git a/gitnexus/test/unit/git.test.ts b/gitnexus/test/unit/git.test.ts new file mode 100644 index 0000000000..c0bd21e2ff --- /dev/null +++ b/gitnexus/test/unit/git.test.ts @@ -0,0 +1,89 @@ +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { execSync } from 'child_process'; +import { isGitRepo, getCurrentCommit, getGitRoot } from '../../src/storage/git.js'; + +// Mock child_process.execSync +vi.mock('child_process', () => ({ + execSync: vi.fn(), +})); + +const mockExecSync = vi.mocked(execSync); + +describe('git utilities', () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + describe('isGitRepo', () => { + it('returns true when inside a git work tree', () => { + mockExecSync.mockReturnValueOnce(Buffer.from('')); + expect(isGitRepo('/project')).toBe(true); + expect(mockExecSync).toHaveBeenCalledWith( + 'git rev-parse --is-inside-work-tree', + { cwd: '/project', stdio: 'ignore' } + ); + }); + + it('returns false when not a git repo', () => { + mockExecSync.mockImplementationOnce(() => { throw new Error('not a git repo'); }); + expect(isGitRepo('/not-a-repo')).toBe(false); + }); + + it('passes the correct cwd', () => { + mockExecSync.mockReturnValueOnce(Buffer.from('')); + isGitRepo('/some/path'); + expect(mockExecSync).toHaveBeenCalledWith( + expect.any(String), + expect.objectContaining({ cwd: '/some/path' }) + ); + }); + }); + + describe('getCurrentCommit', () => { + it('returns trimmed commit hash', () => { + mockExecSync.mockReturnValueOnce(Buffer.from('abc123def\n')); + expect(getCurrentCommit('/project')).toBe('abc123def'); + }); + + it('returns empty string on error', () => { + mockExecSync.mockImplementationOnce(() => { throw new Error('not a git repo'); }); + expect(getCurrentCommit('/not-a-repo')).toBe(''); + }); + + it('trims whitespace from output', () => { + mockExecSync.mockReturnValueOnce(Buffer.from(' sha256hash \n')); + expect(getCurrentCommit('/project')).toBe('sha256hash'); + }); + }); + + describe('getGitRoot', () => { + it('returns resolved path on success', () => { + mockExecSync.mockReturnValueOnce(Buffer.from('/d/Projects/MyRepo\n')); + const result = getGitRoot('/d/Projects/MyRepo/src'); + expect(result).toBeTruthy(); + // path.resolve normalizes the git output + expect(typeof result).toBe('string'); + }); + + it('returns null when not in a git repo', () => { + mockExecSync.mockImplementationOnce(() => { throw new Error('not a git repo'); }); + expect(getGitRoot('/not-a-repo')).toBeNull(); + }); + + it('calls git rev-parse --show-toplevel', () => { + mockExecSync.mockReturnValueOnce(Buffer.from('/repo\n')); + getGitRoot('/repo/src'); + expect(mockExecSync).toHaveBeenCalledWith( + 'git rev-parse --show-toplevel', + expect.objectContaining({ cwd: '/repo/src' }) + ); + }); + + it('trims output before resolving path', () => { + mockExecSync.mockReturnValueOnce(Buffer.from(' /repo \n')); + const result = getGitRoot('/repo/src'); + expect(result).not.toBeNull(); + expect(result!.trim()).toBe(result); + }); + }); +}); diff --git a/gitnexus/test/unit/graph.test.ts b/gitnexus/test/unit/graph.test.ts new file mode 100644 index 0000000000..4e87afc773 --- /dev/null +++ b/gitnexus/test/unit/graph.test.ts @@ -0,0 +1,189 @@ +/** + * P0 Unit Tests: Knowledge Graph + * + * Tests: createKnowledgeGraph() — addNode, getNode, removeNode, + * iterNodes, addRelationship, removeNodesByFile, counts. + */ +import { describe, it, expect } from 'vitest'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import type { GraphNode, GraphRelationship } from '../../src/core/graph/types.js'; + +function makeNode(id: string, name: string, filePath: string = 'src/test.ts'): GraphNode { + return { + id, + label: 'Function', + properties: { name, filePath, startLine: 1, endLine: 10 }, + }; +} + +function makeRel(src: string, tgt: string, type: GraphRelationship['type'] = 'CALLS'): GraphRelationship { + return { + id: `${src}-${type}-${tgt}`, + sourceId: src, + targetId: tgt, + type, + confidence: 1.0, + reason: '', + }; +} + +describe('createKnowledgeGraph', () => { + // ─── addNode / getNode ───────────────────────────────────────────── + + it('adds and retrieves a node', () => { + const g = createKnowledgeGraph(); + const node = makeNode('fn:foo', 'foo'); + g.addNode(node); + expect(g.getNode('fn:foo')).toBe(node); + }); + + it('returns undefined for unknown node', () => { + const g = createKnowledgeGraph(); + expect(g.getNode('nonexistent')).toBeUndefined(); + }); + + it('duplicate addNode is a no-op', () => { + const g = createKnowledgeGraph(); + const node1 = makeNode('fn:foo', 'foo'); + const node2 = makeNode('fn:foo', 'bar'); // same ID, different name + g.addNode(node1); + g.addNode(node2); + expect(g.nodeCount).toBe(1); + expect(g.getNode('fn:foo')!.properties.name).toBe('foo'); // first one wins + }); + + // ─── removeNode ───────────────────────────────────────────────────── + + it('removes a node and its relationships', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + g.addNode(makeNode('fn:b', 'b')); + g.addRelationship(makeRel('fn:a', 'fn:b')); + expect(g.relationshipCount).toBe(1); + + const removed = g.removeNode('fn:a'); + expect(removed).toBe(true); + expect(g.getNode('fn:a')).toBeUndefined(); + expect(g.nodeCount).toBe(1); + expect(g.relationshipCount).toBe(0); // relationship involving fn:a removed + }); + + it('removeNode returns false for unknown node', () => { + const g = createKnowledgeGraph(); + expect(g.removeNode('nope')).toBe(false); + }); + + // ─── removeNodesByFile ────────────────────────────────────────────── + + it('removes all nodes belonging to a file', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a', 'src/foo.ts')); + g.addNode(makeNode('fn:b', 'b', 'src/foo.ts')); + g.addNode(makeNode('fn:c', 'c', 'src/bar.ts')); + + const removed = g.removeNodesByFile('src/foo.ts'); + expect(removed).toBe(2); + expect(g.nodeCount).toBe(1); + expect(g.getNode('fn:c')).toBeDefined(); + }); + + // ─── iterNodes / iterRelationships ───────────────────────────────── + + it('iterNodes yields all nodes', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + g.addNode(makeNode('fn:b', 'b')); + + const ids = [...g.iterNodes()].map(n => n.id); + expect(ids).toHaveLength(2); + expect(ids).toContain('fn:a'); + expect(ids).toContain('fn:b'); + }); + + it('iterRelationships yields all relationships', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + g.addNode(makeNode('fn:b', 'b')); + g.addRelationship(makeRel('fn:a', 'fn:b')); + + const rels = [...g.iterRelationships()]; + expect(rels).toHaveLength(1); + expect(rels[0].sourceId).toBe('fn:a'); + }); + + // ─── nodeCount / relationshipCount ───────────────────────────────── + + it('nodeCount reflects current node count', () => { + const g = createKnowledgeGraph(); + expect(g.nodeCount).toBe(0); + g.addNode(makeNode('fn:a', 'a')); + expect(g.nodeCount).toBe(1); + g.addNode(makeNode('fn:b', 'b')); + expect(g.nodeCount).toBe(2); + }); + + it('relationshipCount reflects current relationship count', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + g.addNode(makeNode('fn:b', 'b')); + expect(g.relationshipCount).toBe(0); + g.addRelationship(makeRel('fn:a', 'fn:b')); + expect(g.relationshipCount).toBe(1); + }); + + // ─── addRelationship ─────────────────────────────────────────────── + + it('duplicate addRelationship is a no-op', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + g.addNode(makeNode('fn:b', 'b')); + g.addRelationship(makeRel('fn:a', 'fn:b')); + g.addRelationship(makeRel('fn:a', 'fn:b')); // same ID + expect(g.relationshipCount).toBe(1); + }); + + // ─── nodes / relationships arrays ────────────────────────────────── + + it('.nodes returns an array copy', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + const arr1 = g.nodes; + const arr2 = g.nodes; + expect(arr1).not.toBe(arr2); // different array instances + expect(arr1).toHaveLength(1); + }); + + it('.relationships returns an array copy', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + g.addNode(makeNode('fn:b', 'b')); + g.addRelationship(makeRel('fn:a', 'fn:b')); + const arr1 = g.relationships; + const arr2 = g.relationships; + expect(arr1).not.toBe(arr2); + expect(arr1).toHaveLength(1); + }); + + // ─── forEachNode / forEachRelationship ────────────────────────────── + + it('forEachNode calls fn for every node', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + g.addNode(makeNode('fn:b', 'b')); + + const ids: string[] = []; + g.forEachNode(n => ids.push(n.id)); + expect(ids).toHaveLength(2); + }); + + it('forEachRelationship calls fn for every relationship', () => { + const g = createKnowledgeGraph(); + g.addNode(makeNode('fn:a', 'a')); + g.addNode(makeNode('fn:b', 'b')); + g.addRelationship(makeRel('fn:a', 'fn:b')); + + const types: string[] = []; + g.forEachRelationship(r => types.push(r.type)); + expect(types).toEqual(['CALLS']); + }); +}); diff --git a/gitnexus/test/unit/has-method.test.ts b/gitnexus/test/unit/has-method.test.ts new file mode 100644 index 0000000000..ba758e2fb0 --- /dev/null +++ b/gitnexus/test/unit/has-method.test.ts @@ -0,0 +1,434 @@ +import { describe, it, expect } from 'vitest'; +import Parser from 'tree-sitter'; +import TypeScript from 'tree-sitter-typescript'; +import Python from 'tree-sitter-python'; +import Java from 'tree-sitter-java'; +import CPP from 'tree-sitter-cpp'; +import Rust from 'tree-sitter-rust'; +import CSharp from 'tree-sitter-c-sharp'; +import Go from 'tree-sitter-go'; +import { findEnclosingClassId, CLASS_CONTAINER_TYPES, CONTAINER_TYPE_TO_LABEL } from '../../src/core/ingestion/utils.js'; + +function parseCode(language: any, code: string): Parser.Tree { + const parser = new Parser(); + parser.setLanguage(language); + return parser.parse(code); +} + +/** Find the first descendant node matching a predicate (BFS). */ +function findNode(root: Parser.SyntaxNode, predicate: (n: Parser.SyntaxNode) => boolean): Parser.SyntaxNode | null { + const queue: Parser.SyntaxNode[] = [root]; + while (queue.length > 0) { + const node = queue.shift()!; + if (predicate(node)) return node; + for (let i = 0; i < node.childCount; i++) { + queue.push(node.child(i)!); + } + } + return null; +} + +describe('CLASS_CONTAINER_TYPES', () => { + it('contains expected class-like AST node types', () => { + expect(CLASS_CONTAINER_TYPES.has('class_declaration')).toBe(true); + expect(CLASS_CONTAINER_TYPES.has('interface_declaration')).toBe(true); + expect(CLASS_CONTAINER_TYPES.has('struct_declaration')).toBe(true); + expect(CLASS_CONTAINER_TYPES.has('impl_item')).toBe(true); + expect(CLASS_CONTAINER_TYPES.has('class_specifier')).toBe(true); + expect(CLASS_CONTAINER_TYPES.has('class_definition')).toBe(true); + }); + + it('does not contain function types', () => { + expect(CLASS_CONTAINER_TYPES.has('function_declaration')).toBe(false); + expect(CLASS_CONTAINER_TYPES.has('function_definition')).toBe(false); + }); +}); + +describe('CONTAINER_TYPE_TO_LABEL', () => { + it('maps class-like types to correct labels', () => { + expect(CONTAINER_TYPE_TO_LABEL['class_declaration']).toBe('Class'); + expect(CONTAINER_TYPE_TO_LABEL['interface_declaration']).toBe('Interface'); + expect(CONTAINER_TYPE_TO_LABEL['struct_declaration']).toBe('Struct'); + expect(CONTAINER_TYPE_TO_LABEL['impl_item']).toBe('Impl'); + expect(CONTAINER_TYPE_TO_LABEL['trait_item']).toBe('Trait'); + expect(CONTAINER_TYPE_TO_LABEL['record_declaration']).toBe('Record'); + expect(CONTAINER_TYPE_TO_LABEL['protocol_declaration']).toBe('Interface'); + }); +}); + +describe('findEnclosingClassId', () => { + const filePath = 'test/example.ts'; + + describe('TypeScript', () => { + it('finds enclosing class for a method', () => { + const tree = parseCode(TypeScript.typescript, ` +class MyService { + getData() { + return 42; + } +} +`); + // Find the method_definition node for getData + const methodNode = findNode(tree.rootNode, n => n.type === 'method_definition'); + expect(methodNode).not.toBeNull(); + + // Find the identifier 'getData' inside the method + const nameNode = findNode(methodNode!, n => n.type === 'property_identifier' && n.text === 'getData'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, filePath); + expect(result).toBe('Class:test/example.ts:MyService'); + }); + + it('finds enclosing interface for a method signature', () => { + const tree = parseCode(TypeScript.typescript, ` +interface MyInterface { + doSomething(): void; +} +`); + // In TS, interface methods are method_signature nodes — find method name + const nameNode = findNode(tree.rootNode, n => n.type === 'property_identifier' && n.text === 'doSomething'); + if (nameNode) { + const result = findEnclosingClassId(nameNode, filePath); + expect(result).toBe('Interface:test/example.ts:MyInterface'); + } + }); + + it('returns null for a top-level function', () => { + const tree = parseCode(TypeScript.typescript, ` +function topLevel() { + return 1; +} +`); + const nameNode = findNode(tree.rootNode, n => n.type === 'identifier' && n.text === 'topLevel'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, filePath); + expect(result).toBeNull(); + }); + + it('returns null when node has no parent', () => { + // Root node's parent is null + const tree = parseCode(TypeScript.typescript, 'const x = 1;'); + const result = findEnclosingClassId(tree.rootNode, filePath); + expect(result).toBeNull(); + }); + }); + + describe('Python', () => { + it('finds enclosing class for a method', () => { + const tree = parseCode(Python, ` +class Calculator: + def add(self, a, b): + return a + b +`); + const methodNode = findNode(tree.rootNode, n => n.type === 'function_definition'); + expect(methodNode).not.toBeNull(); + + const nameNode = findNode(methodNode!, n => n.type === 'identifier' && n.text === 'add'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, 'test/calc.py'); + expect(result).toBe('Class:test/calc.py:Calculator'); + }); + }); + + describe('Java', () => { + it('finds enclosing class for a method', () => { + const tree = parseCode(Java, ` +class UserService { + public void save(User user) {} +} +`); + const methodNode = findNode(tree.rootNode, n => n.type === 'method_declaration'); + expect(methodNode).not.toBeNull(); + + const nameNode = findNode(methodNode!, n => n.type === 'identifier' && n.text === 'save'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, 'test/UserService.java'); + expect(result).toBe('Class:test/UserService.java:UserService'); + }); + + it('finds enclosing interface for a method', () => { + const tree = parseCode(Java, ` +interface Repository { + void findById(int id); +} +`); + const methodNode = findNode(tree.rootNode, n => n.type === 'method_declaration'); + expect(methodNode).not.toBeNull(); + + const nameNode = findNode(methodNode!, n => n.type === 'identifier' && n.text === 'findById'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, 'test/Repository.java'); + expect(result).toBe('Interface:test/Repository.java:Repository'); + }); + }); + + describe('C++', () => { + it('finds enclosing class_specifier for a method', () => { + const tree = parseCode(CPP, ` +class Vector { +public: + int size() { return _size; } +private: + int _size; +}; +`); + // In C++ tree-sitter, the class is a class_specifier + const classNode = findNode(tree.rootNode, n => n.type === 'class_specifier'); + expect(classNode).not.toBeNull(); + + // Find a function_definition inside the class + const funcDef = findNode(classNode!, n => n.type === 'function_definition'); + expect(funcDef).not.toBeNull(); + + const nameNode = findNode(funcDef!, n => n.type === 'identifier' && n.text === 'size'); + if (nameNode) { + const result = findEnclosingClassId(nameNode, 'test/vector.h'); + expect(result).toBe('Class:test/vector.h:Vector'); + } + }); + + it('finds enclosing struct_specifier for a method', () => { + const tree = parseCode(CPP, ` +struct Point { + double distance() { return 0; } +}; +`); + const funcDef = findNode(tree.rootNode, n => n.type === 'function_definition'); + if (funcDef) { + const nameNode = findNode(funcDef, n => n.type === 'identifier' && n.text === 'distance'); + if (nameNode) { + const result = findEnclosingClassId(nameNode, 'test/point.h'); + expect(result).toBe('Struct:test/point.h:Point'); + } + } + }); + }); + + describe('Rust', () => { + it('finds enclosing impl_item for a method', () => { + const tree = parseCode(Rust, ` +struct Counter { + count: u32, +} +impl Counter { + fn increment(&mut self) { + self.count += 1; + } +} +`); + const implNode = findNode(tree.rootNode, n => n.type === 'impl_item'); + expect(implNode).not.toBeNull(); + + const funcItem = findNode(implNode!, n => n.type === 'function_item'); + expect(funcItem).not.toBeNull(); + + const nameNode = findNode(funcItem!, n => n.type === 'identifier' && n.text === 'increment'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, 'test/counter.rs'); + expect(result).toBe('Impl:test/counter.rs:Counter'); + }); + + it('picks struct name (not trait name) for impl Trait for Struct', () => { + const tree = parseCode(Rust, ` +struct MyStruct { + value: i32, +} + +trait MyTrait { + fn do_something(&self); +} + +impl MyTrait for MyStruct { + fn do_something(&self) { + println!("{}", self.value); + } +} +`); + // Find the impl_item that has a `for` keyword (impl Trait for Struct) + const implNode = findNode(tree.rootNode, n => + n.type === 'impl_item' && n.children?.some((c: any) => c.text === 'for') + ); + expect(implNode).not.toBeNull(); + + const funcItem = findNode(implNode!, n => n.type === 'function_item'); + expect(funcItem).not.toBeNull(); + + const nameNode = findNode(funcItem!, n => n.type === 'identifier' && n.text === 'do_something'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, 'test/my_struct.rs'); + // Should resolve to MyStruct (the implementing type), NOT MyTrait + expect(result).toBe('Impl:test/my_struct.rs:MyStruct'); + }); + + it('still picks struct name for plain impl Struct (no trait)', () => { + const tree = parseCode(Rust, ` +struct Counter { + count: u32, +} +impl Counter { + fn increment(&mut self) { + self.count += 1; + } +} +`); + const implNode = findNode(tree.rootNode, n => n.type === 'impl_item'); + expect(implNode).not.toBeNull(); + + const funcItem = findNode(implNode!, n => n.type === 'function_item'); + expect(funcItem).not.toBeNull(); + + const nameNode = findNode(funcItem!, n => n.type === 'identifier' && n.text === 'increment'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, 'test/counter.rs'); + expect(result).toBe('Impl:test/counter.rs:Counter'); + }); + + it('finds enclosing trait_item for a method', () => { + const tree = parseCode(Rust, ` +trait Drawable { + fn draw(&self); +} +`); + const traitNode = findNode(tree.rootNode, n => n.type === 'trait_item'); + expect(traitNode).not.toBeNull(); + + const funcItem = findNode(traitNode!, n => n.type === 'function_signature_item' || n.type === 'function_item'); + if (funcItem) { + const nameNode = findNode(funcItem, n => n.type === 'identifier' && n.text === 'draw'); + if (nameNode) { + const result = findEnclosingClassId(nameNode, 'test/draw.rs'); + expect(result).toBe('Trait:test/draw.rs:Drawable'); + } + } + }); + }); + + describe('C#', () => { + it('finds enclosing class for a method', () => { + const tree = parseCode(CSharp, ` +class OrderService { + public void Process() {} +} +`); + const methodNode = findNode(tree.rootNode, n => n.type === 'method_declaration'); + expect(methodNode).not.toBeNull(); + + const nameNode = findNode(methodNode!, n => n.type === 'identifier' && n.text === 'Process'); + expect(nameNode).not.toBeNull(); + + const result = findEnclosingClassId(nameNode!, 'test/OrderService.cs'); + expect(result).toBe('Class:test/OrderService.cs:OrderService'); + }); + + it('finds enclosing record for a method', () => { + const tree = parseCode(CSharp, ` +record Person { + public string GetName() { return ""; } +} +`); + const methodNode = findNode(tree.rootNode, n => n.type === 'method_declaration'); + if (methodNode) { + const nameNode = findNode(methodNode, n => n.type === 'identifier' && n.text === 'GetName'); + if (nameNode) { + const result = findEnclosingClassId(nameNode, 'test/Person.cs'); + expect(result).toBe('Record:test/Person.cs:Person'); + } + } + }); + + it('finds enclosing struct for a method', () => { + const tree = parseCode(CSharp, ` +struct Vector2 { + public float Length() { return 0; } +} +`); + const methodNode = findNode(tree.rootNode, n => n.type === 'method_declaration'); + if (methodNode) { + const nameNode = findNode(methodNode, n => n.type === 'identifier' && n.text === 'Length'); + if (nameNode) { + const result = findEnclosingClassId(nameNode, 'test/Vector2.cs'); + expect(result).toBe('Struct:test/Vector2.cs:Vector2'); + } + } + }); + }); + + describe('Go', () => { + it('returns receiver struct ID for Go methods', () => { + // Go methods have receiver parameter: func (s *Server) Start() {} + // findEnclosingClassId extracts the receiver type to link method → struct + const tree = parseCode(Go, ` +package main + +type Server struct { + port int +} + +func (s *Server) Start() {} +`); + const methodNode = findNode(tree.rootNode, n => n.type === 'method_declaration'); + expect(methodNode).not.toBeNull(); + + const nameNode = findNode(methodNode!, n => n.type === 'field_identifier' && n.text === 'Start'); + if (nameNode) { + const result = findEnclosingClassId(nameNode, 'test/server.go'); + expect(result).not.toBeNull(); + // Should generate a Struct ID for "Server" + expect(result).toContain('Server'); + } + }); + }); + + describe('edge cases', () => { + it('handles nested classes — returns innermost enclosing class', () => { + const tree = parseCode(TypeScript.typescript, ` +class Outer { + inner = class Inner { + doWork() {} + } +} +`); + const methodNode = findNode(tree.rootNode, n => n.type === 'method_definition'); + if (methodNode) { + const nameNode = findNode(methodNode, n => n.type === 'property_identifier' && n.text === 'doWork'); + if (nameNode) { + const result = findEnclosingClassId(nameNode, filePath); + // Should find the innermost class (Inner, which is a class node) + expect(result).not.toBeNull(); + // The result should reference the inner class, not the outer + } + } + }); + + it('returns null for a node without parent', () => { + // Simulate a node with null parent + const fakeNode = { parent: null }; + const result = findEnclosingClassId(fakeNode, filePath); + expect(result).toBeNull(); + }); + + it('skips containers without a name node', () => { + // Simulate AST nodes where the class container has no name + const fakeClassNode = { + type: 'class_declaration', + childForFieldName: () => null, + children: [], + parent: null, + }; + const fakeChild = { + parent: fakeClassNode, + }; + const result = findEnclosingClassId(fakeChild, filePath); + // The class has no name, so should return null + expect(result).toBeNull(); + }); + }); +}); diff --git a/gitnexus/test/unit/heritage-processor.test.ts b/gitnexus/test/unit/heritage-processor.test.ts new file mode 100644 index 0000000000..8a2a4f56d6 --- /dev/null +++ b/gitnexus/test/unit/heritage-processor.test.ts @@ -0,0 +1,299 @@ +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { processHeritageFromExtracted } from '../../src/core/ingestion/heritage-processor.js'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import { createResolutionContext, type ResolutionContext } from '../../src/core/ingestion/resolution-context.js'; +import type { ExtractedHeritage } from '../../src/core/ingestion/workers/parse-worker.js'; + +describe('processHeritageFromExtracted', () => { + let graph: ReturnType<typeof createKnowledgeGraph>; + let ctx: ResolutionContext; + + beforeEach(() => { + graph = createKnowledgeGraph(); + ctx = createResolutionContext(); + }); + + describe('extends', () => { + it('creates EXTENDS relationship between classes', async () => { + ctx.symbols.add('src/admin.ts', 'AdminUser', 'Class:src/admin.ts:AdminUser', 'Class'); + ctx.symbols.add('src/user.ts', 'User', 'Class:src/user.ts:User', 'Class'); + + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/admin.ts', + className: 'AdminUser', + parentName: 'User', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const rels = graph.relationships.filter(r => r.type === 'EXTENDS'); + expect(rels).toHaveLength(1); + expect(rels[0].sourceId).toBe('Class:src/admin.ts:AdminUser'); + expect(rels[0].targetId).toBe('Class:src/user.ts:User'); + expect(rels[0].confidence).toBe(1.0); + }); + + it('uses generated ID when class not in symbol table', async () => { + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/admin.ts', + className: 'AdminUser', + parentName: 'BaseUser', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const rels = graph.relationships.filter(r => r.type === 'EXTENDS'); + expect(rels).toHaveLength(1); + expect(rels[0].sourceId).toContain('AdminUser'); + expect(rels[0].targetId).toContain('BaseUser'); + }); + + it('skips self-inheritance', async () => { + ctx.symbols.add('src/a.ts', 'Foo', 'Class:src/a.ts:Foo', 'Class'); + + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/a.ts', + className: 'Foo', + parentName: 'Foo', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + expect(graph.relationshipCount).toBe(0); + }); + }); + + describe('implements', () => { + it('creates IMPLEMENTS relationship', async () => { + ctx.symbols.add('src/service.ts', 'UserService', 'Class:src/service.ts:UserService', 'Class'); + ctx.symbols.add('src/interfaces.ts', 'IService', 'Interface:src/interfaces.ts:IService', 'Interface'); + + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/service.ts', + className: 'UserService', + parentName: 'IService', + kind: 'implements', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const rels = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + expect(rels).toHaveLength(1); + expect(rels[0].sourceId).toBe('Class:src/service.ts:UserService'); + }); + }); + + describe('trait-impl (Rust)', () => { + it('creates IMPLEMENTS relationship for trait impl', async () => { + ctx.symbols.add('src/point.rs', 'Point', 'Struct:src/point.rs:Point', 'Struct'); + ctx.symbols.add('src/display.rs', 'Display', 'Trait:src/display.rs:Display', 'Trait'); + + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/point.rs', + className: 'Point', + parentName: 'Display', + kind: 'trait-impl', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const rels = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + expect(rels).toHaveLength(1); + expect(rels[0].reason).toBe('trait-impl'); + }); + }); + + describe('C# interface resolution from extends captures', () => { + it('emits IMPLEMENTS when parent is an Interface in symbol table', async () => { + ctx.symbols.add('src/Service.cs', 'UserService', 'Class:src/Service.cs:UserService', 'Class'); + ctx.symbols.add('src/IService.cs', 'IService', 'Interface:src/IService.cs:IService', 'Interface'); + + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/Service.cs', + className: 'UserService', + parentName: 'IService', + kind: 'extends', // C# base_list always sends extends + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const impls = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + const exts = graph.relationships.filter(r => r.type === 'EXTENDS'); + expect(impls).toHaveLength(1); + expect(exts).toHaveLength(0); + expect(impls[0].sourceId).toBe('Class:src/Service.cs:UserService'); + expect(impls[0].targetId).toBe('Interface:src/IService.cs:IService'); + }); + + it('emits EXTENDS when parent is a Class in symbol table', async () => { + ctx.symbols.add('src/Admin.cs', 'AdminUser', 'Class:src/Admin.cs:AdminUser', 'Class'); + ctx.symbols.add('src/User.cs', 'User', 'Class:src/User.cs:User', 'Class'); + + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/Admin.cs', + className: 'AdminUser', + parentName: 'User', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const exts = graph.relationships.filter(r => r.type === 'EXTENDS'); + const impls = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + expect(exts).toHaveLength(1); + expect(impls).toHaveLength(0); + }); + + it('uses I[A-Z] heuristic for unresolved interface names in C#', async () => { + // IDisposable is not in symbol table (external .NET type) + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/Resource.cs', + className: 'Resource', + parentName: 'IDisposable', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const impls = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + expect(impls).toHaveLength(1); + expect(impls[0].targetId).toContain('IDisposable'); + }); + + it('does not apply I[A-Z] heuristic for TypeScript — unresolved IFoo should be EXTENDS', async () => { + // The I[A-Z] convention is C#/Java-specific; TypeScript files should not be affected + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/service.ts', + className: 'MyService', + parentName: 'IFoo', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const exts = graph.relationships.filter(r => r.type === 'EXTENDS'); + const impls = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + expect(exts).toHaveLength(1); + expect(impls).toHaveLength(0); + }); + + it('does not misclassify non-I-prefixed unresolved names as interfaces', async () => { + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/Derived.cs', + className: 'Derived', + parentName: 'BaseClass', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const exts = graph.relationships.filter(r => r.type === 'EXTENDS'); + const impls = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + expect(exts).toHaveLength(1); + expect(impls).toHaveLength(0); + }); + + it('does not match single-letter I names like "I" or "Id"', async () => { + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/Thing.cs', + className: 'Thing', + parentName: 'Id', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + // "Id" starts with I but second char is lowercase — should be EXTENDS + const exts = graph.relationships.filter(r => r.type === 'EXTENDS'); + expect(exts).toHaveLength(1); + }); + + it('handles mixed class + interface base_list from C#', async () => { + ctx.symbols.add('src/Repo.cs', 'UserRepo', 'Class:src/Repo.cs:UserRepo', 'Class'); + ctx.symbols.add('src/Base.cs', 'BaseRepository', 'Class:src/Base.cs:BaseRepository', 'Class'); + ctx.symbols.add('src/IRepo.cs', 'IRepository', 'Interface:src/IRepo.cs:IRepository', 'Interface'); + ctx.symbols.add('src/IDisp.cs', 'IDisposable', 'Interface:src/IDisp.cs:IDisposable', 'Interface'); + + const heritage: ExtractedHeritage[] = [ + { filePath: 'src/Repo.cs', className: 'UserRepo', parentName: 'BaseRepository', kind: 'extends' }, + { filePath: 'src/Repo.cs', className: 'UserRepo', parentName: 'IRepository', kind: 'extends' }, + { filePath: 'src/Repo.cs', className: 'UserRepo', parentName: 'IDisposable', kind: 'extends' }, + ]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const exts = graph.relationships.filter(r => r.type === 'EXTENDS'); + const impls = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + expect(exts).toHaveLength(1); // BaseRepository + expect(impls).toHaveLength(2); // IRepository + IDisposable + }); + }); + + describe('Swift protocol conformance from extends captures', () => { + it('defaults unresolved PascalCase protocol names to IMPLEMENTS for Swift', async () => { + // Codable, Hashable, Equatable etc. are protocols — no I-prefix convention in Swift + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/Model.swift', + className: 'User', + parentName: 'Codable', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const impls = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + const exts = graph.relationships.filter(r => r.type === 'EXTENDS'); + expect(impls).toHaveLength(1); + expect(exts).toHaveLength(0); + expect(impls[0].targetId).toContain('Codable'); + }); + + it('still uses symbol table authoritatively for Swift (Tier 1 takes precedence)', async () => { + // When the parent is in the symbol table as a Class, EXTENDS wins even in Swift + ctx.symbols.add('src/Animal.swift', 'Animal', 'Class:src/Animal.swift:Animal', 'Class'); + + const heritage: ExtractedHeritage[] = [{ + filePath: 'src/Dog.swift', + className: 'Dog', + parentName: 'Animal', + kind: 'extends', + }]; + + await processHeritageFromExtracted(graph, heritage, ctx); + + const exts = graph.relationships.filter(r => r.type === 'EXTENDS'); + const impls = graph.relationships.filter(r => r.type === 'IMPLEMENTS'); + expect(exts).toHaveLength(1); + expect(impls).toHaveLength(0); + }); + }); + + it('handles multiple heritage entries', async () => { + const heritage: ExtractedHeritage[] = [ + { filePath: 'src/a.ts', className: 'A', parentName: 'B', kind: 'extends' }, + { filePath: 'src/c.ts', className: 'C', parentName: 'D', kind: 'implements' }, + { filePath: 'src/e.rs', className: 'E', parentName: 'F', kind: 'trait-impl' }, + ]; + + await processHeritageFromExtracted(graph, heritage, ctx); + expect(graph.relationships.filter(r => r.type === 'EXTENDS')).toHaveLength(1); + expect(graph.relationships.filter(r => r.type === 'IMPLEMENTS')).toHaveLength(2); + }); + + it('calls progress callback', async () => { + const heritage: ExtractedHeritage[] = [ + { filePath: 'src/a.ts', className: 'A', parentName: 'B', kind: 'extends' }, + ]; + + const onProgress = vi.fn(); + await processHeritageFromExtracted(graph, heritage, ctx, onProgress); + expect(onProgress).toHaveBeenCalledWith(1, 1); + }); + + it('handles empty heritage array', async () => { + await processHeritageFromExtracted(graph, [], ctx); + expect(graph.relationshipCount).toBe(0); + }); +}); diff --git a/gitnexus/test/unit/hooks.test.ts b/gitnexus/test/unit/hooks.test.ts new file mode 100644 index 0000000000..667151e6f1 --- /dev/null +++ b/gitnexus/test/unit/hooks.test.ts @@ -0,0 +1,536 @@ +/** + * Regression Tests: Claude Code Hooks + * + * Tests the hook scripts (gitnexus-hook.cjs and gitnexus-hook.js) that run + * as PreToolUse and PostToolUse hooks in Claude Code. + * + * Covers: + * - extractPattern: pattern extraction from Grep/Glob/Bash tool inputs + * - findGitNexusDir: .gitnexus directory discovery + * - handlePostToolUse: staleness detection after git mutations + * - cwd validation: rejects relative paths (defense-in-depth) + * - shell injection: verifies no shell: true in spawnSync calls + * - dispatch map: correct handler routing + * - cross-platform: Windows .cmd extension handling + * + * Since the hooks are CJS scripts that call main() on load, we test them + * by spawning them as child processes with controlled stdin JSON. + */ +import { describe, it, expect, beforeAll, afterAll } from 'vitest'; +import { spawnSync } from 'child_process'; +import fs from 'fs'; +import path from 'path'; +import os from 'os'; +import { runHook, parseHookOutput } from '../utils/hook-test-helpers.js'; + +// ─── Paths to both hook variants ──────────────────────────────────── + +const CJS_HOOK = path.resolve(__dirname, '..', '..', 'hooks', 'claude', 'gitnexus-hook.cjs'); +const PLUGIN_HOOK = path.resolve(__dirname, '..', '..', '..', 'gitnexus-claude-plugin', 'hooks', 'gitnexus-hook.js'); + +// ─── Test fixtures: temporary .gitnexus directory ─────────────────── + +let tmpDir: string; +let gitNexusDir: string; + +beforeAll(() => { + tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitnexus-hook-test-')); + gitNexusDir = path.join(tmpDir, '.gitnexus'); + fs.mkdirSync(gitNexusDir, { recursive: true }); + + // Initialize a bare git repo so git rev-parse HEAD works + spawnSync('git', ['init'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['config', 'user.email', 'test@test.com'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['config', 'user.name', 'Test'], { cwd: tmpDir, stdio: 'pipe' }); + fs.writeFileSync(path.join(tmpDir, 'dummy.txt'), 'hello'); + spawnSync('git', ['add', '.'], { cwd: tmpDir, stdio: 'pipe' }); + spawnSync('git', ['commit', '-m', 'init'], { cwd: tmpDir, stdio: 'pipe' }); +}); + +afterAll(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); +}); + +// ─── Helper to get HEAD commit hash ───────────────────────────────── + +function getHeadCommit(): string { + const result = spawnSync('git', ['rev-parse', 'HEAD'], { + cwd: tmpDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], + }); + return (result.stdout || '').trim(); +} + +// ─── Both hook files should exist ─────────────────────────────────── + +describe('Hook files exist', () => { + it('CJS hook exists', () => { + expect(fs.existsSync(CJS_HOOK)).toBe(true); + }); + + it('Plugin hook exists', () => { + expect(fs.existsSync(PLUGIN_HOOK)).toBe(true); + }); +}); + +// ─── Source code regression: no shell: true ────────────────────────── + +describe('Shell injection regression', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label} hook has no shell: true in spawnSync calls`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + // Match spawnSync calls with shell option set to true or a variable + // Allowed: comments mentioning shell: true, string literals + const lines = source.split('\n'); + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + // Skip comments and string literals + if (line.trim().startsWith('//') || line.trim().startsWith('*')) continue; + // Check for shell: true or shell: isWin in actual code + if (/shell:\s*(true|isWin)/.test(line)) { + throw new Error(`${label} hook line ${i + 1} has shell injection risk: ${line.trim()}`); + } + } + }); + } +}); + +// ─── Source code regression: .cmd extensions for Windows ───────────── + +describe('Windows .cmd extension handling', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label} hook uses .cmd extensions for Windows npx`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain("npx.cmd"); + }); + } + + it('Plugin hook uses .cmd extension for Windows gitnexus binary', () => { + const source = fs.readFileSync(PLUGIN_HOOK, 'utf-8'); + expect(source).toContain("gitnexus.cmd"); + }); +}); + +// ─── Source code regression: cwd validation ───────────────────────── + +describe('cwd validation guards', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label} hook validates cwd is absolute path`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + const cwdChecks = (source.match(/path\.isAbsolute\(cwd\)/g) || []).length; + // Should have at least 2 checks (one in PreToolUse, one in PostToolUse) + expect(cwdChecks).toBeGreaterThanOrEqual(2); + }); + } +}); + +// ─── Source code regression: sendHookResponse used consistently ────── + +describe('sendHookResponse consistency', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label} hook uses sendHookResponse in both handlers`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + const calls = (source.match(/sendHookResponse\(/g) || []).length; + // At least 3: definition + PreToolUse call + PostToolUse call + expect(calls).toBeGreaterThanOrEqual(3); + }); + + it(`${label} hook does not inline hookSpecificOutput JSON in handlers`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + // Count inline hookSpecificOutput usage (should only be in sendHookResponse definition) + const inlineCount = (source.match(/hookSpecificOutput/g) || []).length; + // Exactly 1 occurrence: inside the sendHookResponse function body + expect(inlineCount).toBe(1); + }); + } +}); + +// ─── Source code regression: dispatch map pattern ──────────────────── + +describe('Dispatch map pattern', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label} hook uses dispatch map instead of if/else`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain('const handlers = {'); + expect(source).toContain('PreToolUse: handlePreToolUse'); + expect(source).toContain('PostToolUse: handlePostToolUse'); + // Should NOT have if/else dispatch in main() + expect(source).not.toMatch(/if\s*\(hookEvent\s*===\s*'PreToolUse'\)/); + }); + } +}); + +// ─── Source code regression: debug error truncation ────────────────── + +describe('Debug error message truncation', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label} hook truncates error messages to 200 chars`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain('.slice(0, 200)'); + }); + } +}); + +// ─── extractPattern regression (via source analysis) ──────────────── + +describe('extractPattern coverage', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label} hook extracts pattern from Grep tool input`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain("toolName === 'Grep'"); + expect(source).toContain('toolInput.pattern'); + }); + + it(`${label} hook extracts pattern from Glob tool input`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain("toolName === 'Glob'"); + }); + + it(`${label} hook extracts pattern from Bash grep/rg commands`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toMatch(/\\brg\\b.*\\bgrep\\b/); + }); + + it(`${label} hook rejects patterns shorter than 3 chars`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain('cleaned.length >= 3'); + }); + } +}); + +// ─── PostToolUse: git mutation regex coverage ─────────────────────── + +describe('Git mutation regex', () => { + const GIT_REGEX = /\\bgit\\s\+\(commit\|merge\|rebase\|cherry-pick\|pull\)/; + + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label} hook detects git commit`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain('commit'); + }); + + it(`${label} hook detects git merge`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain('merge'); + }); + + it(`${label} hook detects git rebase`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain('rebase'); + }); + + it(`${label} hook detects git cherry-pick`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + expect(source).toContain('cherry-pick'); + }); + + it(`${label} hook detects git pull`, () => { + const source = fs.readFileSync(hookPath, 'utf-8'); + // 'pull' in the regex alternation + expect(source).toMatch(/commit\|merge\|rebase\|cherry-pick\|pull/); + }); + } +}); + +// ─── Integration: PostToolUse staleness detection ─────────────────── + +describe('PostToolUse staleness detection (integration)', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label}: emits stale notification when HEAD differs from meta`, () => { + // Write meta.json with a different commit + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'aaaaaaa0000000000000000000000000deadbeef', stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.hookEventName).toBe('PostToolUse'); + expect(output!.additionalContext).toContain('stale'); + expect(output!.additionalContext).toContain('aaaaaaa'); + }); + + it(`${label}: silent when HEAD matches meta lastCommit`, () => { + const head = getHeadCommit(); + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: head, stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + expect(result.stdout.trim()).toBe(''); + }); + + it(`${label}: silent when tool is not Bash`, () => { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Grep', + tool_input: { command: 'git commit -m "test"' }, + cwd: tmpDir, + }); + expect(result.stdout.trim()).toBe(''); + }); + + it(`${label}: silent when command is not a git mutation`, () => { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git status' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + expect(result.stdout.trim()).toBe(''); + }); + + it(`${label}: silent when exit code is non-zero`, () => { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "fail"' }, + tool_output: { exit_code: 1 }, + cwd: tmpDir, + }); + expect(result.stdout.trim()).toBe(''); + }); + + it(`${label}: includes --embeddings in suggestion when meta had embeddings`, () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'deadbeef', stats: { embeddings: 42 } }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git merge feature' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).toContain('--embeddings'); + }); + + it(`${label}: omits --embeddings when meta had no embeddings`, () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'deadbeef', stats: { embeddings: 0 } }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).not.toContain('--embeddings'); + }); + + it(`${label}: detects git rebase as a mutation`, () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'oldcommit', stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git rebase main' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).toContain('stale'); + }); + + it(`${label}: detects git cherry-pick as a mutation`, () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'oldcommit', stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git cherry-pick abc123' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + }); + + it(`${label}: detects git pull as a mutation`, () => { + fs.writeFileSync( + path.join(gitNexusDir, 'meta.json'), + JSON.stringify({ lastCommit: 'oldcommit', stats: {} }), + ); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git pull origin main' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + }); + } +}); + +// ─── Integration: cwd validation rejects relative paths ───────────── + +describe('cwd validation (integration)', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label}: PostToolUse silent when cwd is relative`, () => { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: 'relative/path', + }); + expect(result.stdout.trim()).toBe(''); + }); + + it(`${label}: PreToolUse silent when cwd is relative`, () => { + const result = runHook(hookPath, { + hook_event_name: 'PreToolUse', + tool_name: 'Grep', + tool_input: { pattern: 'validateUser' }, + cwd: 'relative/path', + }); + expect(result.stdout.trim()).toBe(''); + }); + } +}); + +// ─── Integration: dispatch map routes correctly ───────────────────── + +describe('Dispatch map routing (integration)', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label}: unknown hook_event_name produces no output`, () => { + const result = runHook(hookPath, { + hook_event_name: 'UnknownEvent', + tool_name: 'Bash', + tool_input: { command: 'echo hello' }, + cwd: tmpDir, + }); + expect(result.stdout.trim()).toBe(''); + expect(result.status).toBe(0); + }); + + it(`${label}: empty hook_event_name produces no output`, () => { + const result = runHook(hookPath, { + hook_event_name: '', + tool_name: 'Bash', + cwd: tmpDir, + }); + expect(result.stdout.trim()).toBe(''); + expect(result.status).toBe(0); + }); + + it(`${label}: missing hook_event_name produces no output`, () => { + const result = runHook(hookPath, { + tool_name: 'Bash', + cwd: tmpDir, + }); + expect(result.stdout.trim()).toBe(''); + expect(result.status).toBe(0); + }); + + it(`${label}: invalid JSON input exits cleanly`, () => { + const result = spawnSync(process.execPath, [hookPath], { + input: 'not json at all', + encoding: 'utf-8', + timeout: 10000, + stdio: ['pipe', 'pipe', 'pipe'], + }); + expect(result.status).toBe(0); + expect(result.stdout.trim()).toBe(''); + }); + + it(`${label}: empty stdin exits cleanly`, () => { + const result = spawnSync(process.execPath, [hookPath], { + input: '', + encoding: 'utf-8', + timeout: 10000, + stdio: ['pipe', 'pipe', 'pipe'], + }); + expect(result.status).toBe(0); + }); + } +}); + +// ─── Integration: PostToolUse with missing meta.json ──────────────── + +describe('PostToolUse with missing/corrupt meta.json', () => { + for (const [label, hookPath] of [['CJS', CJS_HOOK], ['Plugin', PLUGIN_HOOK]] as const) { + it(`${label}: emits stale when meta.json does not exist`, () => { + const metaPath = path.join(gitNexusDir, 'meta.json'); + const hadMeta = fs.existsSync(metaPath); + if (hadMeta) fs.unlinkSync(metaPath); + + try { + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).toContain('never'); + } finally { + // Restore meta.json for subsequent tests + fs.writeFileSync(metaPath, JSON.stringify({ lastCommit: 'old', stats: {} })); + } + }); + + it(`${label}: emits stale when meta.json is corrupt`, () => { + const metaPath = path.join(gitNexusDir, 'meta.json'); + fs.writeFileSync(metaPath, 'not valid json!!!'); + + const result = runHook(hookPath, { + hook_event_name: 'PostToolUse', + tool_name: 'Bash', + tool_input: { command: 'git commit -m "test"' }, + tool_output: { exit_code: 0 }, + cwd: tmpDir, + }); + + const output = parseHookOutput(result.stdout); + expect(output).not.toBeNull(); + expect(output!.additionalContext).toContain('never'); + + // Restore + fs.writeFileSync(metaPath, JSON.stringify({ lastCommit: 'old', stats: {} })); + }); + } +}); diff --git a/gitnexus/test/unit/hybrid-search.test.ts b/gitnexus/test/unit/hybrid-search.test.ts new file mode 100644 index 0000000000..4250c38862 --- /dev/null +++ b/gitnexus/test/unit/hybrid-search.test.ts @@ -0,0 +1,126 @@ +/** + * P1 Unit Tests: Hybrid Search (mergeWithRRF) + * + * Tests: mergeWithRRF from hybrid-search.ts + * - BM25-only merge + * - Semantic-only merge + * - Combined ranking + * - Limit parameter + * - Empty inputs + */ +import { describe, it, expect } from 'vitest'; +import { mergeWithRRF } from '../../src/core/search/hybrid-search.js'; +import type { BM25SearchResult } from '../../src/core/search/bm25-index.js'; +import type { SemanticSearchResult } from '../../src/core/embeddings/types.js'; + +let bm25Rank = 0; +function makeBM25(filePath: string, score: number): BM25SearchResult { + return { filePath, score, rank: ++bm25Rank }; +} + +function makeSemantic(filePath: string, distance: number): SemanticSearchResult { + return { + filePath, + distance, + nodeId: `node:${filePath}`, + name: filePath.split('/').pop()!.replace(/\.\w+$/, ''), + label: 'Function', + startLine: 1, + endLine: 10, + }; +} + +describe('mergeWithRRF', () => { + it('handles empty inputs', () => { + const result = mergeWithRRF([], []); + expect(result).toHaveLength(0); + }); + + it('handles BM25-only results', () => { + const bm25: BM25SearchResult[] = [ + makeBM25('src/a.ts', 10), + makeBM25('src/b.ts', 5), + ]; + const result = mergeWithRRF(bm25, []); + expect(result).toHaveLength(2); + expect(result[0].filePath).toBe('src/a.ts'); + expect(result[0].sources).toEqual(['bm25']); + expect(result[0].rank).toBe(1); + expect(result[1].rank).toBe(2); + }); + + it('handles semantic-only results', () => { + const semantic: SemanticSearchResult[] = [ + makeSemantic('src/a.ts', 0.1), + makeSemantic('src/b.ts', 0.2), + ]; + const result = mergeWithRRF([], semantic); + expect(result).toHaveLength(2); + expect(result[0].filePath).toBe('src/a.ts'); + expect(result[0].sources).toEqual(['semantic']); + }); + + it('combined: shared results get higher score', () => { + const bm25: BM25SearchResult[] = [ + makeBM25('src/shared.ts', 10), + makeBM25('src/bm25-only.ts', 5), + ]; + const semantic: SemanticSearchResult[] = [ + makeSemantic('src/shared.ts', 0.1), + makeSemantic('src/semantic-only.ts', 0.2), + ]; + + const result = mergeWithRRF(bm25, semantic); + // Shared result should be ranked first (higher combined RRF score) + expect(result[0].filePath).toBe('src/shared.ts'); + expect(result[0].sources).toContain('bm25'); + expect(result[0].sources).toContain('semantic'); + // Its score should be higher than any single-source result + expect(result[0].score).toBeGreaterThan(result[1].score); + }); + + it('respects limit parameter', () => { + const bm25: BM25SearchResult[] = Array.from({ length: 20 }, (_, i) => + makeBM25(`src/${i}.ts`, 100 - i), + ); + const result = mergeWithRRF(bm25, [], 5); + expect(result).toHaveLength(5); + }); + + it('default limit is 10', () => { + const bm25: BM25SearchResult[] = Array.from({ length: 20 }, (_, i) => + makeBM25(`src/${i}.ts`, 100 - i), + ); + const result = mergeWithRRF(bm25, []); + expect(result).toHaveLength(10); + }); + + it('assigns ranks starting from 1', () => { + const bm25: BM25SearchResult[] = [ + makeBM25('src/a.ts', 10), + makeBM25('src/b.ts', 5), + makeBM25('src/c.ts', 1), + ]; + const result = mergeWithRRF(bm25, []); + expect(result.map(r => r.rank)).toEqual([1, 2, 3]); + }); + + it('preserves semantic metadata on shared results', () => { + const bm25: BM25SearchResult[] = [makeBM25('src/a.ts', 10)]; + const semantic: SemanticSearchResult[] = [makeSemantic('src/a.ts', 0.1)]; + + const result = mergeWithRRF(bm25, semantic); + expect(result[0].nodeId).toBe('node:src/a.ts'); + expect(result[0].name).toBe('a'); + expect(result[0].label).toBe('Function'); + }); + + it('stores original scores for debugging', () => { + const bm25: BM25SearchResult[] = [makeBM25('src/a.ts', 15)]; + const semantic: SemanticSearchResult[] = [makeSemantic('src/a.ts', 0.3)]; + + const result = mergeWithRRF(bm25, semantic); + expect(result[0].bm25Score).toBe(15); + expect(result[0].semanticScore).toBeCloseTo(0.7); // 1 - distance + }); +}); diff --git a/gitnexus/test/unit/ignore-service.test.ts b/gitnexus/test/unit/ignore-service.test.ts new file mode 100644 index 0000000000..8866b548b3 --- /dev/null +++ b/gitnexus/test/unit/ignore-service.test.ts @@ -0,0 +1,359 @@ +import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import os from 'os'; +import { shouldIgnorePath, isHardcodedIgnoredDirectory, loadIgnoreRules, createIgnoreFilter } from '../../src/config/ignore-service.js'; + +describe('shouldIgnorePath', () => { + describe('version control directories', () => { + it.each(['.git', '.svn', '.hg', '.bzr'])('ignores %s directory', (dir) => { + expect(shouldIgnorePath(`${dir}/config`)).toBe(true); + expect(shouldIgnorePath(`project/${dir}/HEAD`)).toBe(true); + }); + }); + + describe('IDE/editor directories', () => { + it.each(['.idea', '.vscode', '.vs'])('ignores %s directory', (dir) => { + expect(shouldIgnorePath(`${dir}/settings.json`)).toBe(true); + }); + }); + + describe('dependency directories', () => { + it.each([ + 'node_modules', 'vendor', 'venv', '.venv', '__pycache__', + 'site-packages', '.mypy_cache', '.pytest_cache', + ])('ignores %s directory', (dir) => { + expect(shouldIgnorePath(`project/${dir}/some-file.js`)).toBe(true); + }); + }); + + describe('build output directories', () => { + it.each([ + 'dist', 'build', 'out', 'output', 'bin', 'obj', 'target', + '.next', '.nuxt', '.vercel', '.parcel-cache', '.turbo', + ])('ignores %s directory', (dir) => { + expect(shouldIgnorePath(`${dir}/bundle.js`)).toBe(true); + }); + }); + + describe('test/coverage directories', () => { + it.each(['coverage', '__tests__', '__mocks__', '.nyc_output'])('ignores %s directory', (dir) => { + expect(shouldIgnorePath(`${dir}/results.json`)).toBe(true); + }); + }); + + describe('ignored file extensions', () => { + it.each([ + // Images + '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.webp', + // Archives + '.zip', '.tar', '.gz', '.rar', + // Binary/Compiled + '.exe', '.dll', '.so', '.dylib', '.class', '.jar', '.pyc', '.wasm', + // Documents + '.pdf', '.doc', '.docx', + // Media + '.mp4', '.mp3', '.wav', + // Fonts + '.woff', '.woff2', '.ttf', + // Databases + '.db', '.sqlite', + // Source maps + '.map', + // Lock files + '.lock', + // Certificates + '.pem', '.key', '.crt', + // Data files + '.csv', '.parquet', '.pkl', + ])('ignores files with %s extension', (ext) => { + expect(shouldIgnorePath(`assets/file${ext}`)).toBe(true); + }); + }); + + describe('ignored files by exact name', () => { + it.each([ + 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', + 'composer.lock', 'Cargo.lock', 'go.sum', + '.gitignore', '.gitattributes', '.npmrc', '.editorconfig', + '.prettierrc', '.eslintignore', '.dockerignore', + 'LICENSE', 'LICENSE.md', 'CHANGELOG.md', + '.env', '.env.local', '.env.production', + ])('ignores %s', (fileName) => { + expect(shouldIgnorePath(fileName)).toBe(true); + expect(shouldIgnorePath(`project/${fileName}`)).toBe(true); + }); + }); + + describe('compound extensions', () => { + it('ignores .min.js files', () => { + expect(shouldIgnorePath('dist/bundle.min.js')).toBe(true); + }); + + it('ignores .bundle.js files', () => { + expect(shouldIgnorePath('dist/app.bundle.js')).toBe(true); + }); + + it('ignores .chunk.js files', () => { + expect(shouldIgnorePath('dist/vendor.chunk.js')).toBe(true); + }); + + it('ignores .min.css files', () => { + expect(shouldIgnorePath('dist/styles.min.css')).toBe(true); + }); + }); + + describe('generated files', () => { + it('ignores .generated. files', () => { + expect(shouldIgnorePath('src/api.generated.ts')).toBe(true); + }); + + it('ignores TypeScript declaration files', () => { + expect(shouldIgnorePath('types/index.d.ts')).toBe(true); + }); + }); + + describe('Windows path normalization', () => { + it('normalizes backslashes to forward slashes', () => { + expect(shouldIgnorePath('node_modules\\express\\index.js')).toBe(true); + expect(shouldIgnorePath('project\\.git\\HEAD')).toBe(true); + }); + }); + + describe('files that should NOT be ignored', () => { + it.each([ + 'src/index.ts', + 'src/components/Button.tsx', + 'lib/utils.py', + 'cmd/server/main.go', + 'src/main.rs', + 'app/Models/User.php', + 'Sources/App.swift', + 'src/App.java', + 'src/main.c', + 'src/main.cpp', + 'src/Program.cs', + ])('does not ignore source file %s', (filePath) => { + expect(shouldIgnorePath(filePath)).toBe(false); + }); + }); +}); + +describe('isHardcodedIgnoredDirectory', () => { + it('returns true for known ignored directories', () => { + expect(isHardcodedIgnoredDirectory('node_modules')).toBe(true); + expect(isHardcodedIgnoredDirectory('.git')).toBe(true); + expect(isHardcodedIgnoredDirectory('dist')).toBe(true); + expect(isHardcodedIgnoredDirectory('__pycache__')).toBe(true); + }); + + it('returns false for source directories', () => { + expect(isHardcodedIgnoredDirectory('src')).toBe(false); + expect(isHardcodedIgnoredDirectory('lib')).toBe(false); + expect(isHardcodedIgnoredDirectory('app')).toBe(false); + expect(isHardcodedIgnoredDirectory('local')).toBe(false); + }); +}); + +describe('loadIgnoreRules', () => { + let tmpDir: string; + + beforeAll(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-ignore-test-')); + }); + + afterAll(async () => { + await fs.rm(tmpDir, { recursive: true, force: true }); + }); + + it('returns null when no ignore files exist', async () => { + const result = await loadIgnoreRules(tmpDir); + expect(result).toBeNull(); + }); + + it('parses .gitignore file', async () => { + await fs.writeFile(path.join(tmpDir, '.gitignore'), 'data/\nlogs/\n'); + const ig = await loadIgnoreRules(tmpDir); + expect(ig).not.toBeNull(); + expect(ig!.ignores('data/file.txt')).toBe(true); + expect(ig!.ignores('logs/app.log')).toBe(true); + expect(ig!.ignores('src/index.ts')).toBe(false); + await fs.unlink(path.join(tmpDir, '.gitignore')); + }); + + it('parses .gitnexusignore file', async () => { + await fs.writeFile(path.join(tmpDir, '.gitnexusignore'), 'vendor/\n*.test.ts\n'); + const ig = await loadIgnoreRules(tmpDir); + expect(ig).not.toBeNull(); + expect(ig!.ignores('vendor/lib.js')).toBe(true); + expect(ig!.ignores('src/app.test.ts')).toBe(true); + expect(ig!.ignores('src/app.ts')).toBe(false); + await fs.unlink(path.join(tmpDir, '.gitnexusignore')); + }); + + it('combines both files', async () => { + await fs.writeFile(path.join(tmpDir, '.gitignore'), 'data/\n'); + await fs.writeFile(path.join(tmpDir, '.gitnexusignore'), 'vendor/\n'); + const ig = await loadIgnoreRules(tmpDir); + expect(ig).not.toBeNull(); + expect(ig!.ignores('data/file.txt')).toBe(true); + expect(ig!.ignores('vendor/lib.js')).toBe(true); + expect(ig!.ignores('src/index.ts')).toBe(false); + await fs.unlink(path.join(tmpDir, '.gitignore')); + await fs.unlink(path.join(tmpDir, '.gitnexusignore')); + }); + + it('handles comments and blank lines', async () => { + await fs.writeFile(path.join(tmpDir, '.gitignore'), '# comment\n\ndata/\n\n# another comment\n'); + const ig = await loadIgnoreRules(tmpDir); + expect(ig).not.toBeNull(); + expect(ig!.ignores('data/file.txt')).toBe(true); + expect(ig!.ignores('src/index.ts')).toBe(false); + await fs.unlink(path.join(tmpDir, '.gitignore')); + }); +}); + +describe('createIgnoreFilter', () => { + let tmpDir: string; + + beforeAll(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-filter-test-')); + }); + + afterAll(async () => { + await fs.rm(tmpDir, { recursive: true, force: true }); + }); + + it('creates a filter with ignored and childrenIgnored methods', async () => { + const filter = await createIgnoreFilter(tmpDir); + expect(typeof filter.ignored).toBe('function'); + expect(typeof filter.childrenIgnored).toBe('function'); + }); + + it('childrenIgnored returns true for hardcoded directories', async () => { + const filter = await createIgnoreFilter(tmpDir); + // Simulate a Path-like object + const mockPath = { name: 'node_modules', relative: () => 'node_modules' } as any; + expect(filter.childrenIgnored(mockPath)).toBe(true); + + const srcPath = { name: 'src', relative: () => 'src' } as any; + expect(filter.childrenIgnored(srcPath)).toBe(false); + }); + + it('childrenIgnored returns true for gitignored directories', async () => { + await fs.writeFile(path.join(tmpDir, '.gitignore'), 'local/\n'); + const filter = await createIgnoreFilter(tmpDir); + + const localPath = { name: 'local', relative: () => 'local' } as any; + expect(filter.childrenIgnored(localPath)).toBe(true); + + const srcPath = { name: 'src', relative: () => 'src' } as any; + expect(filter.childrenIgnored(srcPath)).toBe(false); + + await fs.unlink(path.join(tmpDir, '.gitignore')); + }); + + it('childrenIgnored returns true for bare-name directory patterns (no trailing slash)', async () => { + await fs.writeFile(path.join(tmpDir, '.gitignore'), 'local\n'); + const filter = await createIgnoreFilter(tmpDir); + + const localPath = { name: 'local', relative: () => 'local' } as any; + expect(filter.childrenIgnored(localPath)).toBe(true); + + const srcPath = { name: 'src', relative: () => 'src' } as any; + expect(filter.childrenIgnored(srcPath)).toBe(false); + + await fs.unlink(path.join(tmpDir, '.gitignore')); + }); + + it('ignored returns true for file-glob patterns like *.log', async () => { + await fs.writeFile(path.join(tmpDir, '.gitignore'), '*.log\n'); + const filter = await createIgnoreFilter(tmpDir); + + const logPath = { name: 'app.log', relative: () => 'app.log' } as any; + expect(filter.ignored(logPath)).toBe(true); + + const tsPath = { name: 'index.ts', relative: () => 'src/index.ts' } as any; + expect(filter.ignored(tsPath)).toBe(false); + + await fs.unlink(path.join(tmpDir, '.gitignore')); + }); +}); + +describe('loadIgnoreRules — error handling', () => { + let tmpDir: string; + + beforeAll(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-err-test-')); + }); + + afterAll(async () => { + await fs.rm(tmpDir, { recursive: true, force: true }); + }); + + it.skipIf(process.platform === 'win32')('warns on EACCES but does not throw', async () => { + const gitignorePath = path.join(tmpDir, '.gitignore'); + await fs.writeFile(gitignorePath, 'data/\n'); + await fs.chmod(gitignorePath, 0o000); + + const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {}); + const result = await loadIgnoreRules(tmpDir); + // Should still return (null or partial), not throw + expect(result).toBeNull(); + expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('.gitignore')); + + warnSpy.mockRestore(); + await fs.chmod(gitignorePath, 0o644); + await fs.unlink(gitignorePath); + }); +}); + +describe('loadIgnoreRules — GITNEXUS_NO_GITIGNORE env var', () => { + let tmpDir: string; + + beforeAll(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-noignore-test-')); + }); + + afterAll(async () => { + await fs.rm(tmpDir, { recursive: true, force: true }); + }); + + it('skips .gitignore when GITNEXUS_NO_GITIGNORE is set', async () => { + await fs.writeFile(path.join(tmpDir, '.gitignore'), 'data/\n'); + + const original = process.env.GITNEXUS_NO_GITIGNORE; + process.env.GITNEXUS_NO_GITIGNORE = '1'; + try { + const ig = await loadIgnoreRules(tmpDir); + // .gitignore should be skipped — no rules loaded + expect(ig).toBeNull(); + } finally { + if (original === undefined) { + delete process.env.GITNEXUS_NO_GITIGNORE; + } else { + process.env.GITNEXUS_NO_GITIGNORE = original; + } + await fs.unlink(path.join(tmpDir, '.gitignore')); + } + }); + + it('still reads .gitnexusignore when GITNEXUS_NO_GITIGNORE is set', async () => { + await fs.writeFile(path.join(tmpDir, '.gitnexusignore'), 'vendor/\n'); + + const original = process.env.GITNEXUS_NO_GITIGNORE; + process.env.GITNEXUS_NO_GITIGNORE = '1'; + try { + const ig = await loadIgnoreRules(tmpDir); + expect(ig).not.toBeNull(); + expect(ig!.ignores('vendor/lib.js')).toBe(true); + } finally { + if (original === undefined) { + delete process.env.GITNEXUS_NO_GITIGNORE; + } else { + process.env.GITNEXUS_NO_GITIGNORE = original; + } + await fs.unlink(path.join(tmpDir, '.gitnexusignore')); + } + }); +}); diff --git a/gitnexus/test/unit/import-processor.test.ts b/gitnexus/test/unit/import-processor.test.ts new file mode 100644 index 0000000000..e41a516889 --- /dev/null +++ b/gitnexus/test/unit/import-processor.test.ts @@ -0,0 +1,87 @@ +import { describe, it, expect, beforeEach } from 'vitest'; +import { buildImportResolutionContext, type ImportResolutionContext } from '../../src/core/ingestion/import-processor.js'; +import { createResolutionContext } from '../../src/core/ingestion/resolution-context.js'; + +describe('ResolutionContext.importMap', () => { + it('creates an empty Map', () => { + const map = createResolutionContext().importMap; + expect(map).toBeInstanceOf(Map); + expect(map.size).toBe(0); + }); + + it('can be used to store import relationships', () => { + const map = createResolutionContext().importMap; + map.set('src/index.ts', new Set(['src/utils.ts', 'src/types.ts'])); + expect(map.get('src/index.ts')!.size).toBe(2); + expect(map.get('src/index.ts')!.has('src/utils.ts')).toBe(true); + }); +}); + +describe('buildImportResolutionContext', () => { + let ctx: ImportResolutionContext; + const testPaths = [ + 'src/index.ts', + 'src/utils.ts', + 'src/components/Button.tsx', + 'src/lib/helpers.ts', + ]; + + beforeEach(() => { + ctx = buildImportResolutionContext(testPaths); + }); + + it('creates a Set of all file paths', () => { + expect(ctx.allFilePaths).toBeInstanceOf(Set); + expect(ctx.allFilePaths.size).toBe(4); + expect(ctx.allFilePaths.has('src/index.ts')).toBe(true); + }); + + it('stores the original file list', () => { + expect(ctx.allFileList).toBe(testPaths); + }); + + it('creates normalized file list with forward slashes', () => { + const winPaths = ['src\\index.ts', 'src\\utils.ts']; + const winCtx = buildImportResolutionContext(winPaths); + expect(winCtx.normalizedFileList[0]).toBe('src/index.ts'); + expect(winCtx.normalizedFileList[1]).toBe('src/utils.ts'); + }); + + it('creates a suffix index for O(1) lookups', () => { + expect(ctx.suffixIndex).toBeDefined(); + expect(typeof ctx.suffixIndex.get).toBe('function'); + }); + + it('initializes empty resolve cache', () => { + expect(ctx.resolveCache).toBeInstanceOf(Map); + expect(ctx.resolveCache.size).toBe(0); + }); + + it('handles empty paths array', () => { + const emptyCtx = buildImportResolutionContext([]); + expect(emptyCtx.allFilePaths.size).toBe(0); + expect(emptyCtx.allFileList).toHaveLength(0); + }); + + describe('suffix index', () => { + it('resolves file by suffix', () => { + const result = ctx.suffixIndex.get('utils.ts'); + expect(result).toBeDefined(); + }); + + it('resolves file by full path', () => { + const result = ctx.suffixIndex.get('src/index.ts'); + expect(result).toBeDefined(); + }); + + it('resolves nested component path', () => { + const result = ctx.suffixIndex.get('components/Button.tsx'); + expect(result).toBeDefined(); + }); + + it('returns undefined for non-existent suffix', () => { + const result = ctx.suffixIndex.get('nonexistent.ts'); + expect(result).toBeUndefined(); + }); + }); +}); diff --git a/gitnexus/test/unit/ingestion-utils.test.ts b/gitnexus/test/unit/ingestion-utils.test.ts new file mode 100644 index 0000000000..08415bb1ad --- /dev/null +++ b/gitnexus/test/unit/ingestion-utils.test.ts @@ -0,0 +1,674 @@ +import { describe, it, expect } from 'vitest'; +import { getLanguageFromFilename, isBuiltInOrNoise, extractFunctionName } from '../../src/core/ingestion/utils.js'; +import { getTreeSitterBufferSize, TREE_SITTER_BUFFER_SIZE, TREE_SITTER_MAX_BUFFER } from '../../src/core/ingestion/constants.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; +import Parser from 'tree-sitter'; +import C from 'tree-sitter-c'; +import CPP from 'tree-sitter-cpp'; +import Python from 'tree-sitter-python'; +import TypeScript from 'tree-sitter-typescript'; + +describe('getLanguageFromFilename', () => { + describe('TypeScript', () => { + it('detects .ts files', () => { + expect(getLanguageFromFilename('index.ts')).toBe(SupportedLanguages.TypeScript); + }); + + it('detects .tsx files', () => { + expect(getLanguageFromFilename('Component.tsx')).toBe(SupportedLanguages.TypeScript); + }); + + it('detects .ts files in paths', () => { + expect(getLanguageFromFilename('src/core/utils.ts')).toBe(SupportedLanguages.TypeScript); + }); + }); + + describe('JavaScript', () => { + it('detects .js files', () => { + expect(getLanguageFromFilename('index.js')).toBe(SupportedLanguages.JavaScript); + }); + + it('detects .jsx files', () => { + expect(getLanguageFromFilename('App.jsx')).toBe(SupportedLanguages.JavaScript); + }); + }); + + describe('Python', () => { + it('detects .py files', () => { + expect(getLanguageFromFilename('main.py')).toBe(SupportedLanguages.Python); + }); + }); + + describe('Java', () => { + it('detects .java files', () => { + expect(getLanguageFromFilename('Main.java')).toBe(SupportedLanguages.Java); + }); + }); + + describe('C', () => { + it('detects .c files', () => { + expect(getLanguageFromFilename('main.c')).toBe(SupportedLanguages.C); + }); + }); + + describe('C++', () => { + it.each(['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh'])( + 'detects %s files', + (ext) => { + expect(getLanguageFromFilename(`file${ext}`)).toBe(SupportedLanguages.CPlusPlus); + } + ); + }); + + describe('C#', () => { + it('detects .cs files', () => { + expect(getLanguageFromFilename('Program.cs')).toBe(SupportedLanguages.CSharp); + }); + }); + + describe('Go', () => { + it('detects .go files', () => { + expect(getLanguageFromFilename('main.go')).toBe(SupportedLanguages.Go); + }); + }); + + describe('Rust', () => { + it('detects .rs files', () => { + expect(getLanguageFromFilename('main.rs')).toBe(SupportedLanguages.Rust); + }); + }); + + describe('PHP', () => { + it.each(['.php', '.phtml', '.php3', '.php4', '.php5', '.php8'])( + 'detects %s files', + (ext) => { + expect(getLanguageFromFilename(`file${ext}`)).toBe(SupportedLanguages.PHP); + } + ); + }); + + describe('Swift', () => { + it('detects .swift files', () => { + expect(getLanguageFromFilename('App.swift')).toBe(SupportedLanguages.Swift); + }); + }); + + describe('Ruby', () => { + it.each(['.rb', '.rake', '.gemspec'])( + 'detects %s files', + (ext) => { + expect(getLanguageFromFilename(`file${ext}`)).toBe(SupportedLanguages.Ruby); + } + ); + + it('detects extensionless Rakefile', () => { + expect(getLanguageFromFilename('Rakefile')).toBe(SupportedLanguages.Ruby); + }); + + it('detects extensionless Gemfile', () => { + expect(getLanguageFromFilename('Gemfile')).toBe(SupportedLanguages.Ruby); + }); + }); + + describe('Kotlin', () => { + it.each(['.kt', '.kts'])( + 'detects %s files', + (ext) => { + expect(getLanguageFromFilename(`file${ext}`)).toBe(SupportedLanguages.Kotlin); + } + ); + }); + + describe('unsupported', () => { + it.each(['.scala', '.r', '.lua', '.zig', '.txt', '.md', '.json', '.yaml'])( + 'returns null for %s files', + (ext) => { + expect(getLanguageFromFilename(`file${ext}`)).toBeNull(); + } + ); + + it('returns null for files without extension', () => { + expect(getLanguageFromFilename('Makefile')).toBeNull(); + }); + + it('returns null for empty string', () => { + expect(getLanguageFromFilename('')).toBeNull(); + }); + }); +}); + +describe('isBuiltInOrNoise', () => { + describe('JavaScript/TypeScript', () => { + it('filters console methods', () => { + expect(isBuiltInOrNoise('console')).toBe(true); + expect(isBuiltInOrNoise('log')).toBe(true); + expect(isBuiltInOrNoise('warn')).toBe(true); + }); + + it('filters React hooks', () => { + expect(isBuiltInOrNoise('useState')).toBe(true); + expect(isBuiltInOrNoise('useEffect')).toBe(true); + expect(isBuiltInOrNoise('useCallback')).toBe(true); + }); + + it('filters array methods', () => { + expect(isBuiltInOrNoise('map')).toBe(true); + expect(isBuiltInOrNoise('filter')).toBe(true); + expect(isBuiltInOrNoise('reduce')).toBe(true); + }); + }); + + describe('Python', () => { + it('filters built-in functions', () => { + expect(isBuiltInOrNoise('print')).toBe(true); + expect(isBuiltInOrNoise('len')).toBe(true); + expect(isBuiltInOrNoise('range')).toBe(true); + }); + }); + + describe('PHP', () => { + it('filters PHP built-in functions', () => { + expect(isBuiltInOrNoise('echo')).toBe(true); + expect(isBuiltInOrNoise('isset')).toBe(true); + expect(isBuiltInOrNoise('date')).toBe(true); + expect(isBuiltInOrNoise('json_encode')).toBe(true); + expect(isBuiltInOrNoise('array_map')).toBe(true); + }); + + it('filters PHP string functions', () => { + expect(isBuiltInOrNoise('strlen')).toBe(true); + expect(isBuiltInOrNoise('substr')).toBe(true); + expect(isBuiltInOrNoise('str_replace')).toBe(true); + }); + }); + + describe('C/C++', () => { + it('filters standard library functions', () => { + expect(isBuiltInOrNoise('printf')).toBe(true); + expect(isBuiltInOrNoise('malloc')).toBe(true); + expect(isBuiltInOrNoise('free')).toBe(true); + }); + + it('filters Linux kernel macros', () => { + expect(isBuiltInOrNoise('container_of')).toBe(true); + expect(isBuiltInOrNoise('ARRAY_SIZE')).toBe(true); + expect(isBuiltInOrNoise('pr_info')).toBe(true); + }); + }); + + describe('Kotlin', () => { + it('filters stdlib functions', () => { + expect(isBuiltInOrNoise('println')).toBe(true); + expect(isBuiltInOrNoise('listOf')).toBe(true); + expect(isBuiltInOrNoise('TODO')).toBe(true); + }); + + it('filters coroutine functions', () => { + expect(isBuiltInOrNoise('launch')).toBe(true); + expect(isBuiltInOrNoise('async')).toBe(true); + }); + }); + + describe('Swift', () => { + it('filters built-in functions', () => { + expect(isBuiltInOrNoise('print')).toBe(true); + expect(isBuiltInOrNoise('fatalError')).toBe(true); + }); + + it('filters UIKit methods', () => { + expect(isBuiltInOrNoise('addSubview')).toBe(true); + expect(isBuiltInOrNoise('reloadData')).toBe(true); + }); + }); + + describe('Rust', () => { + it('filters Result/Option methods', () => { + expect(isBuiltInOrNoise('unwrap')).toBe(true); + expect(isBuiltInOrNoise('expect')).toBe(true); + expect(isBuiltInOrNoise('unwrap_or')).toBe(true); + expect(isBuiltInOrNoise('unwrap_or_else')).toBe(true); + expect(isBuiltInOrNoise('unwrap_or_default')).toBe(true); + expect(isBuiltInOrNoise('ok')).toBe(true); + expect(isBuiltInOrNoise('err')).toBe(true); + expect(isBuiltInOrNoise('is_ok')).toBe(true); + expect(isBuiltInOrNoise('is_err')).toBe(true); + expect(isBuiltInOrNoise('map_err')).toBe(true); + expect(isBuiltInOrNoise('and_then')).toBe(true); + expect(isBuiltInOrNoise('or_else')).toBe(true); + }); + + it('filters trait conversion methods', () => { + expect(isBuiltInOrNoise('clone')).toBe(true); + expect(isBuiltInOrNoise('to_string')).toBe(true); + expect(isBuiltInOrNoise('to_owned')).toBe(true); + expect(isBuiltInOrNoise('into')).toBe(true); + expect(isBuiltInOrNoise('from')).toBe(true); + expect(isBuiltInOrNoise('as_ref')).toBe(true); + expect(isBuiltInOrNoise('as_mut')).toBe(true); + }); + + it('filters iterator methods', () => { + expect(isBuiltInOrNoise('iter')).toBe(true); + expect(isBuiltInOrNoise('into_iter')).toBe(true); + expect(isBuiltInOrNoise('collect')).toBe(true); + expect(isBuiltInOrNoise('fold')).toBe(true); + expect(isBuiltInOrNoise('for_each')).toBe(true); + }); + + it('filters collection methods', () => { + expect(isBuiltInOrNoise('len')).toBe(true); + expect(isBuiltInOrNoise('is_empty')).toBe(true); + expect(isBuiltInOrNoise('push')).toBe(true); + expect(isBuiltInOrNoise('pop')).toBe(true); + expect(isBuiltInOrNoise('insert')).toBe(true); + expect(isBuiltInOrNoise('remove')).toBe(true); + expect(isBuiltInOrNoise('contains')).toBe(true); + }); + + it('filters macro-like and panic functions', () => { + expect(isBuiltInOrNoise('format')).toBe(true); + expect(isBuiltInOrNoise('panic')).toBe(true); + expect(isBuiltInOrNoise('unreachable')).toBe(true); + expect(isBuiltInOrNoise('todo')).toBe(true); + expect(isBuiltInOrNoise('unimplemented')).toBe(true); + expect(isBuiltInOrNoise('vec')).toBe(true); + expect(isBuiltInOrNoise('println')).toBe(true); + expect(isBuiltInOrNoise('eprintln')).toBe(true); + expect(isBuiltInOrNoise('dbg')).toBe(true); + }); + + it('filters sync primitives', () => { + expect(isBuiltInOrNoise('lock')).toBe(true); + expect(isBuiltInOrNoise('try_lock')).toBe(true); + expect(isBuiltInOrNoise('spawn')).toBe(true); + expect(isBuiltInOrNoise('join')).toBe(true); + expect(isBuiltInOrNoise('sleep')).toBe(true); + }); + + it('filters enum constructors', () => { + expect(isBuiltInOrNoise('Some')).toBe(true); + expect(isBuiltInOrNoise('None')).toBe(true); + expect(isBuiltInOrNoise('Ok')).toBe(true); + expect(isBuiltInOrNoise('Err')).toBe(true); + }); + + it('does not filter user-defined Rust functions', () => { + expect(isBuiltInOrNoise('process_request')).toBe(false); + expect(isBuiltInOrNoise('handle_connection')).toBe(false); + expect(isBuiltInOrNoise('build_response')).toBe(false); + }); + }); + + describe('C#/.NET', () => { + it('filters Console I/O', () => { + expect(isBuiltInOrNoise('Console')).toBe(true); + expect(isBuiltInOrNoise('WriteLine')).toBe(true); + expect(isBuiltInOrNoise('ReadLine')).toBe(true); + }); + + it('filters LINQ methods', () => { + expect(isBuiltInOrNoise('Where')).toBe(true); + expect(isBuiltInOrNoise('Select')).toBe(true); + expect(isBuiltInOrNoise('GroupBy')).toBe(true); + expect(isBuiltInOrNoise('OrderBy')).toBe(true); + expect(isBuiltInOrNoise('FirstOrDefault')).toBe(true); + expect(isBuiltInOrNoise('ToList')).toBe(true); + }); + + it('filters Task async methods', () => { + expect(isBuiltInOrNoise('Task')).toBe(true); + expect(isBuiltInOrNoise('Run')).toBe(true); + expect(isBuiltInOrNoise('WhenAll')).toBe(true); + expect(isBuiltInOrNoise('ConfigureAwait')).toBe(true); + }); + + it('filters Object base methods', () => { + expect(isBuiltInOrNoise('ToString')).toBe(true); + expect(isBuiltInOrNoise('GetType')).toBe(true); + expect(isBuiltInOrNoise('Equals')).toBe(true); + expect(isBuiltInOrNoise('GetHashCode')).toBe(true); + }); + }); + + describe('user-defined functions', () => { + it('does not filter custom function names', () => { + expect(isBuiltInOrNoise('myCustomFunction')).toBe(false); + expect(isBuiltInOrNoise('processData')).toBe(false); + expect(isBuiltInOrNoise('handleUserRequest')).toBe(false); + }); + }); +}); + +describe('extractFunctionName', () => { + const parser = new Parser(); + + describe('C', () => { + it('extracts function name from C function definition', () => { + parser.setLanguage(C); + const code = `int main() { return 0; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('main'); + expect(result.label).toBe('Function'); + }); + + it('extracts function name with parameters', () => { + parser.setLanguage(C); + const code = `void helper(int a, char* b) {}`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('helper'); + expect(result.label).toBe('Function'); + }); + }); + + describe('C++', () => { + it('extracts method name from C++ class method definition', () => { + parser.setLanguage(CPP); + const code = `int MyClass::OnEncryptData() { return 0; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('OnEncryptData'); + expect(result.label).toBe('Method'); + }); + + it('extracts method name with namespace', () => { + parser.setLanguage(CPP); + const code = `void HuksListener::OnDataOprEvent(int type, DataInfo& info) {}`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('OnDataOprEvent'); + expect(result.label).toBe('Method'); + }); + + it('extracts C function (not method)', () => { + parser.setLanguage(CPP); + const code = `void standalone_function() {}`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('standalone_function'); + expect(result.label).toBe('Function'); + }); + + it('extracts method with parenthesized declarator', () => { + parser.setLanguage(CPP); + const code = `void (MyClass::handler)() {}`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('handler'); + expect(result.label).toBe('Method'); + }); + }); + + describe('C pointer returns', () => { + it('extracts name from function returning pointer', () => { + parser.setLanguage(C); + const code = `int* get_data() { return 0; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('get_data'); + expect(result.label).toBe('Function'); + }); + + it('extracts name from function returning double pointer', () => { + parser.setLanguage(C); + const code = `char** get_strings() { return 0; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('get_strings'); + expect(result.label).toBe('Function'); + }); + + it('extracts name from struct pointer return', () => { + parser.setLanguage(C); + const code = `struct Node* create_node(int val) { return 0; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('create_node'); + expect(result.label).toBe('Function'); + }); + }); + + describe('C++ pointer/reference returns', () => { + it('extracts name from method returning pointer', () => { + parser.setLanguage(CPP); + const code = `int* MyClass::getData() { return nullptr; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('getData'); + expect(result.label).toBe('Method'); + }); + + it('extracts name from function returning reference', () => { + parser.setLanguage(CPP); + const code = `std::string& get_name() { static std::string s; return s; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('get_name'); + expect(result.label).toBe('Function'); + }); + + it('extracts name from method returning reference', () => { + parser.setLanguage(CPP); + const code = `int& Container::at(int i) { return data[i]; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('at'); + expect(result.label).toBe('Method'); + }); + + it('extracts name from method returning const reference', () => { + parser.setLanguage(CPP); + const code = `const std::string& Config::getName() const { return name_; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('getName'); + expect(result.label).toBe('Method'); + }); + }); + + describe('C++ destructors', () => { + it('extracts destructor name from out-of-line definition', () => { + parser.setLanguage(CPP); + const code = `MyClass::~MyClass() { cleanup(); }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + // destructor_name includes the ~ prefix + expect(result.funcName).toBe('~MyClass'); + expect(result.label).toBe('Method'); + }); + }); + + describe('TypeScript', () => { + it('extracts arrow function name from variable declarator', () => { + parser.setLanguage(TypeScript.typescript); + const code = `const myHandler = () => { return 1; }`; + const tree = parser.parse(code); + const program = tree.rootNode; + const varDecl = program.child(0); + const declarator = varDecl!.namedChild(0); + const arrowFunc = declarator!.namedChild(1); + + const result = extractFunctionName(arrowFunc); + + expect(result.funcName).toBe('myHandler'); + expect(result.label).toBe('Function'); + }); + + it('extracts function expression name from variable declarator', () => { + parser.setLanguage(TypeScript.typescript); + const code = `const processItem = function() { }`; + const tree = parser.parse(code); + const program = tree.rootNode; + const varDecl = program.child(0); + const declarator = varDecl!.namedChild(0); + const funcExpr = declarator!.namedChild(1); + + const result = extractFunctionName(funcExpr); + + expect(result.funcName).toBe('processItem'); + expect(result.label).toBe('Function'); + }); + }); + + describe('Python', () => { + it('extracts function name from Python function definition', () => { + parser.setLanguage(Python); + const code = `def hello_world():\n pass`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('hello_world'); + expect(result.label).toBe('Function'); + }); + + it('extracts function name with parameters', () => { + parser.setLanguage(Python); + const code = `def calculate_sum(a, b):\n return a + b`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('calculate_sum'); + expect(result.label).toBe('Function'); + }); + + it('extracts async function name', () => { + parser.setLanguage(Python); + const code = `async def fetch_data():\n pass`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('fetch_data'); + expect(result.label).toBe('Function'); + }); + + it('extracts function name with type hints', () => { + parser.setLanguage(Python); + const code = `def process_data(items: list[int]) -> bool:\n return True`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.child(0); + + const result = extractFunctionName(funcNode); + + expect(result.funcName).toBe('process_data'); + expect(result.label).toBe('Function'); + }); + + it('extracts nested function name', () => { + parser.setLanguage(Python); + const code = `def outer():\n def inner():\n pass`; + const tree = parser.parse(code); + const outerFunc = tree.rootNode.child(0); + const block = outerFunc!.child(4); + const innerFunc = block!.namedChild(0); + + const result = extractFunctionName(innerFunc); + + expect(result.funcName).toBe('inner'); + expect(result.label).toBe('Function'); + }); + }); +}); + +describe('getTreeSitterBufferSize', () => { + it('returns minimum 512KB for small files', () => { + expect(getTreeSitterBufferSize(100)).toBe(TREE_SITTER_BUFFER_SIZE); + expect(getTreeSitterBufferSize(0)).toBe(TREE_SITTER_BUFFER_SIZE); + expect(getTreeSitterBufferSize(1000)).toBe(TREE_SITTER_BUFFER_SIZE); + }); + + it('returns 2x content length when larger than minimum', () => { + const size = 400 * 1024; // 400 KB — 2x = 800 KB > 512 KB min + expect(getTreeSitterBufferSize(size)).toBe(size * 2); + }); + + it('caps at 32MB for very large files', () => { + const huge = 20 * 1024 * 1024; // 20 MB — 2x = 40 MB > 32 MB cap + expect(getTreeSitterBufferSize(huge)).toBe(32 * 1024 * 1024); + }); + + it('returns exactly 512KB at the boundary', () => { + // 256KB * 2 = 512KB = minimum, so should return minimum + expect(getTreeSitterBufferSize(256 * 1024)).toBe(TREE_SITTER_BUFFER_SIZE); + }); + + it('scales linearly between min and max', () => { + const small = getTreeSitterBufferSize(300 * 1024); + const medium = getTreeSitterBufferSize(1 * 1024 * 1024); + const large = getTreeSitterBufferSize(5 * 1024 * 1024); + expect(small).toBeLessThan(medium); + expect(medium).toBeLessThan(large); + }); + + it('TREE_SITTER_MAX_BUFFER is 32MB', () => { + expect(TREE_SITTER_MAX_BUFFER).toBe(32 * 1024 * 1024); + }); + + it('returns max buffer at exact boundary (16MB input)', () => { + // 16MB * 2 = 32MB = max + expect(getTreeSitterBufferSize(16 * 1024 * 1024)).toBe(TREE_SITTER_MAX_BUFFER); + }); + + it('file just over max returns max buffer', () => { + // 17MB * 2 = 34MB > 32MB cap + expect(getTreeSitterBufferSize(17 * 1024 * 1024)).toBe(TREE_SITTER_MAX_BUFFER); + }); + + it('handles files between old 512KB limit and new 32MB limit', () => { + // This is the range that was previously silently skipped + const sizes = [600 * 1024, 1024 * 1024, 5 * 1024 * 1024, 10 * 1024 * 1024]; + for (const size of sizes) { + const bufSize = getTreeSitterBufferSize(size); + expect(bufSize).toBeGreaterThanOrEqual(TREE_SITTER_BUFFER_SIZE); + expect(bufSize).toBeLessThanOrEqual(TREE_SITTER_MAX_BUFFER); + } + }); +}); diff --git a/gitnexus/test/unit/language-skip.test.ts b/gitnexus/test/unit/language-skip.test.ts new file mode 100644 index 0000000000..21d3e8f2f8 --- /dev/null +++ b/gitnexus/test/unit/language-skip.test.ts @@ -0,0 +1,48 @@ +import { describe, it, expect } from 'vitest'; +import { isLanguageAvailable, loadLanguage } from '../../src/core/tree-sitter/parser-loader.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; + +describe('isLanguageAvailable', () => { + it('returns true for installed languages', () => { + expect(isLanguageAvailable(SupportedLanguages.TypeScript)).toBe(true); + expect(isLanguageAvailable(SupportedLanguages.JavaScript)).toBe(true); + expect(isLanguageAvailable(SupportedLanguages.Python)).toBe(true); + expect(isLanguageAvailable(SupportedLanguages.Java)).toBe(true); + expect(isLanguageAvailable(SupportedLanguages.Go)).toBe(true); + expect(isLanguageAvailable(SupportedLanguages.Rust)).toBe(true); + expect(isLanguageAvailable(SupportedLanguages.PHP)).toBe(true); + expect(isLanguageAvailable(SupportedLanguages.Ruby)).toBe(true); + }); + + it('returns false for fabricated language values', () => { + expect(isLanguageAvailable('erlang' as SupportedLanguages)).toBe(false); + expect(isLanguageAvailable('haskell' as SupportedLanguages)).toBe(false); + }); + + it('handles Swift based on optional dependency availability', () => { + // Swift is optional — result depends on whether tree-sitter-swift is installed + const result = isLanguageAvailable(SupportedLanguages.Swift); + expect(typeof result).toBe('boolean'); + // Either way, it should not throw + }); + + it('handles Kotlin based on optional dependency availability', () => { + // Kotlin is now optional — result depends on whether tree-sitter-kotlin is installed + const result = isLanguageAvailable(SupportedLanguages.Kotlin); + expect(typeof result).toBe('boolean'); + // Either way, it should not throw + }); +}); + +describe('Kotlin optional dependency', () => { + it('handles Kotlin loading gracefully', async () => { + // Kotlin is optional — it either loads successfully or throws an error + try { + await loadLanguage(SupportedLanguages.Kotlin); + // If it succeeds, tree-sitter-kotlin is installed + } catch (e: any) { + // If it fails, it should be because tree-sitter-kotlin is not installed + expect(e.message).toContain('Unsupported language'); + } + }); +}); diff --git a/gitnexus/test/unit/lazy-action.test.ts b/gitnexus/test/unit/lazy-action.test.ts new file mode 100644 index 0000000000..73b1b92b8a --- /dev/null +++ b/gitnexus/test/unit/lazy-action.test.ts @@ -0,0 +1,21 @@ +import { describe, expect, it, vi } from 'vitest'; +import { createLazyAction } from '../../src/cli/lazy-action.js'; + +describe('createLazyAction', () => { + it('does not import target module until invoked', async () => { + const loader = vi.fn(async () => ({ + run: vi.fn(async () => 'ok'), + })); + + const action = createLazyAction(loader, 'run'); + + expect(loader).not.toHaveBeenCalled(); + await expect(action('arg-1')).resolves.toBeUndefined(); + expect(loader).toHaveBeenCalledTimes(1); + }); + + it('throws a clear error when export is not a function', async () => { + const action = createLazyAction(async () => ({ notAFunction: 'string-value' }), 'notAFunction'); + await expect(action()).rejects.toThrow('notAFunction'); + }); +}); diff --git a/gitnexus/test/unit/method-signature.test.ts b/gitnexus/test/unit/method-signature.test.ts new file mode 100644 index 0000000000..ccd03b4ba4 --- /dev/null +++ b/gitnexus/test/unit/method-signature.test.ts @@ -0,0 +1,424 @@ +import { describe, it, expect } from 'vitest'; +import { extractMethodSignature } from '../../src/core/ingestion/utils.js'; +import Parser from 'tree-sitter'; +import TypeScript from 'tree-sitter-typescript'; +import Python from 'tree-sitter-python'; +import Java from 'tree-sitter-java'; +import CSharp from 'tree-sitter-c-sharp'; +import Kotlin from 'tree-sitter-kotlin'; +import CPP from 'tree-sitter-cpp'; +import Go from 'tree-sitter-go'; +import Rust from 'tree-sitter-rust'; + +describe('extractMethodSignature', () => { + const parser = new Parser(); + + it('returns zero params and no return type for null node', () => { + const sig = extractMethodSignature(null); + expect(sig.parameterCount).toBe(0); + expect(sig.returnType).toBeUndefined(); + }); + + describe('TypeScript', () => { + it('extracts params and return type from a typed method', () => { + parser.setLanguage(TypeScript.typescript); + const code = `class Foo { + greet(name: string, age: number): boolean { return true; } +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(2); + expect(sig.returnType).toBe('boolean'); + }); + + it('extracts zero params from a method with no parameters', () => { + parser.setLanguage(TypeScript.typescript); + const code = `class Foo { + run(): void {} +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(0); + expect(sig.returnType).toBe('void'); + }); + + it('extracts params without return type annotation', () => { + parser.setLanguage(TypeScript.typescript); + const code = `class Foo { + process(x: number) { return x + 1; } +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(1); + expect(sig.returnType).toBeUndefined(); + }); + }); + + describe('Python', () => { + it('skips self parameter', () => { + parser.setLanguage(Python); + const code = `class Foo: + def bar(self, x, y): + pass`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(2); + expect(sig.returnType).toBeUndefined(); + }); + + it('handles method with only self', () => { + parser.setLanguage(Python); + const code = `class Foo: + def noop(self): + pass`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(0); + }); + + it('handles Python return type annotation', () => { + parser.setLanguage(Python); + const code = `class Foo: + def bar(self, x: int) -> bool: + return True`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(1); + // The important thing is parameterCount is correct; returnType may vary. + }); + }); + + describe('Java', () => { + it('extracts params from a Java method', () => { + parser.setLanguage(Java); + const code = `class Foo { + public int add(int a, int b) { return a + b; } +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(2); + }); + + it('extracts zero params from no-arg Java method', () => { + parser.setLanguage(Java); + const code = `class Foo { + public void run() {} +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(0); + }); + }); + + describe('Kotlin', () => { + it('extracts params from a Kotlin function declaration', () => { + parser.setLanguage(Kotlin); + const code = `object OneArg { + fun writeAudit(message: String): String { + return message + } +}`; + const tree = parser.parse(code); + const objectNode = tree.rootNode.child(0)!; + const classBody = objectNode.namedChild(1)!; + const functionNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(functionNode); + expect(sig.parameterCount).toBe(1); + }); + + it('extracts zero params from a no-arg Kotlin function', () => { + parser.setLanguage(Kotlin); + const code = `object ZeroArg { + fun writeAudit(): String { + return "zero" + } +}`; + const tree = parser.parse(code); + const objectNode = tree.rootNode.child(0)!; + const classBody = objectNode.namedChild(1)!; + const functionNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(functionNode); + expect(sig.parameterCount).toBe(0); + }); + }); + + describe('C++', () => { + it('extracts params from a nested C++ declarator', () => { + parser.setLanguage(CPP); + const code = `inline const char* write_audit(const char* message) { + return message; +}`; + const tree = parser.parse(code); + const functionNode = tree.rootNode.namedChild(0)!; + + const sig = extractMethodSignature(functionNode); + expect(sig.parameterCount).toBe(1); + }); + + it('extracts zero params from a no-arg C++ function', () => { + parser.setLanguage(CPP); + const code = `inline const char* write_audit() { + return "zero"; +}`; + const tree = parser.parse(code); + const functionNode = tree.rootNode.namedChild(0)!; + + const sig = extractMethodSignature(functionNode); + expect(sig.parameterCount).toBe(0); + }); + }); + + describe('C#', () => { + it('extracts params from a C# method', () => { + parser.setLanguage(CSharp); + const code = `class Foo { + public bool Check(string name, int count) { return true; } +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(2); + }); + + it('handles C# method with no params', () => { + parser.setLanguage(CSharp); + const code = `class Foo { + public void Execute() {} +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBe(0); + }); + + it('extracts return type from C# method', () => { + parser.setLanguage(CSharp); + const code = `class Svc { + public User GetUser(string name) { return null; } +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.returnType).toBe('User'); + }); + }); + + describe('Go', () => { + it('extracts params and single return type', () => { + parser.setLanguage(Go); + const code = `package main +func add(a int, b int) int { return a + b }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChildren.find(c => c.type === 'function_declaration')!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBe(2); + expect(sig.returnType).toBe('int'); + }); + + it('extracts multi-return type', () => { + parser.setLanguage(Go); + const code = `package main +func parse(s string) (string, error) { return s, nil }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChildren.find(c => c.type === 'function_declaration')!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBe(1); + expect(sig.returnType).toBe('string'); + }); + + it('handles no return type', () => { + parser.setLanguage(Go); + const code = `package main +func doSomething(x int) { }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChildren.find(c => c.type === 'function_declaration')!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBe(1); + expect(sig.returnType).toBeUndefined(); + }); + + it('marks variadic function with undefined parameterCount', () => { + parser.setLanguage(Go); + const code = `package main +func log(args ...string) int { return 0 }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChildren.find(c => c.type === 'function_declaration')!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBeUndefined(); + expect(sig.returnType).toBe('int'); + }); + }); + + describe('Rust', () => { + it('extracts return type from function', () => { + parser.setLanguage(Rust); + const code = `fn add(a: i32, b: i32) -> i32 { a + b }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChild(0)!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBe(2); + expect(sig.returnType).toBe('i32'); + }); + }); + + describe('C++ return types', () => { + it('extracts primitive return type', () => { + parser.setLanguage(CPP); + const code = `int add(int a, int b) { return a + b; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChild(0)!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBe(2); + expect(sig.returnType).toBe('int'); + }); + + it('extracts qualified return type', () => { + parser.setLanguage(CPP); + const code = `std::string getName() { return ""; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChild(0)!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBe(0); + expect(sig.returnType).toBe('std::string'); + }); + + it('returns undefined returnType for void', () => { + parser.setLanguage(CPP); + const code = `void doNothing() { }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChild(0)!; + + const sig = extractMethodSignature(funcNode); + expect(sig.returnType).toBeUndefined(); + }); + + it('marks variadic function with undefined parameterCount', () => { + parser.setLanguage(CPP); + const code = `int printf(const char* fmt, ...) { return 0; }`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChild(0)!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBeUndefined(); + expect(sig.returnType).toBe('int'); + }); + }); + + describe('variadic params', () => { + it('Java: marks varargs with undefined parameterCount', () => { + parser.setLanguage(Java); + const code = `class Foo { + public void log(String fmt, Object... args) {} +}`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBeUndefined(); + }); + + it('Python: marks *args with undefined parameterCount', () => { + parser.setLanguage(Python); + const code = `class Foo: + def log(self, fmt, *args): + pass`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBeUndefined(); + }); + + it('Python: marks **kwargs with undefined parameterCount', () => { + parser.setLanguage(Python); + const code = `class Foo: + def config(self, **kwargs): + pass`; + const tree = parser.parse(code); + const classNode = tree.rootNode.child(0)!; + const classBody = classNode.childForFieldName('body')!; + const methodNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(methodNode); + expect(sig.parameterCount).toBeUndefined(); + }); + + it('TypeScript: marks rest params with undefined parameterCount', () => { + parser.setLanguage(TypeScript.typescript); + const code = `function logEntry(...messages: string[]): void {}`; + const tree = parser.parse(code); + const funcNode = tree.rootNode.namedChild(0)!; + + const sig = extractMethodSignature(funcNode); + expect(sig.parameterCount).toBeUndefined(); + }); + + it('Kotlin: marks vararg with undefined parameterCount', () => { + parser.setLanguage(Kotlin); + const code = `object Foo { + fun log(vararg args: String) {} +}`; + const tree = parser.parse(code); + const objectNode = tree.rootNode.child(0)!; + const classBody = objectNode.namedChild(1)!; + const functionNode = classBody.namedChild(0)!; + + const sig = extractMethodSignature(functionNode); + expect(sig.parameterCount).toBeUndefined(); + }); + }); +}); diff --git a/gitnexus/test/unit/mro-processor.test.ts b/gitnexus/test/unit/mro-processor.test.ts new file mode 100644 index 0000000000..2e4d04a594 --- /dev/null +++ b/gitnexus/test/unit/mro-processor.test.ts @@ -0,0 +1,461 @@ +import { describe, it, expect } from 'vitest'; +import { computeMRO } from '../../src/core/ingestion/mro-processor.js'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import type { KnowledgeGraph } from '../../src/core/graph/types.js'; +import { generateId } from '../../src/lib/utils.js'; + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +function addClass(graph: KnowledgeGraph, name: string, language: string, label: 'Class' | 'Interface' | 'Struct' | 'Trait' = 'Class') { + const id = generateId(label, name); + graph.addNode({ + id, + label, + properties: { name, filePath: `src/${name}.ts`, language }, + }); + return id; +} + +function addMethod(graph: KnowledgeGraph, className: string, methodName: string, classLabel: 'Class' | 'Interface' | 'Struct' | 'Trait' = 'Class') { + const classId = generateId(classLabel, className); + const methodId = generateId('Method', `${className}.${methodName}`); + graph.addNode({ + id: methodId, + label: 'Method', + properties: { name: methodName, filePath: `src/${className}.ts` }, + }); + graph.addRelationship({ + id: generateId('HAS_METHOD', `${classId}->${methodId}`), + sourceId: classId, + targetId: methodId, + type: 'HAS_METHOD', + confidence: 1.0, + reason: '', + }); + return methodId; +} + +function addExtends(graph: KnowledgeGraph, childName: string, parentName: string, childLabel: 'Class' | 'Struct' = 'Class', parentLabel: 'Class' | 'Interface' | 'Trait' = 'Class') { + const childId = generateId(childLabel, childName); + const parentId = generateId(parentLabel, parentName); + graph.addRelationship({ + id: generateId('EXTENDS', `${childId}->${parentId}`), + sourceId: childId, + targetId: parentId, + type: 'EXTENDS', + confidence: 1.0, + reason: '', + }); +} + +function addImplements(graph: KnowledgeGraph, childName: string, parentName: string, childLabel: 'Class' | 'Struct' = 'Class', parentLabel: 'Interface' | 'Trait' = 'Interface') { + const childId = generateId(childLabel, childName); + const parentId = generateId(parentLabel, parentName); + graph.addRelationship({ + id: generateId('IMPLEMENTS', `${childId}->${parentId}`), + sourceId: childId, + targetId: parentId, + type: 'IMPLEMENTS', + confidence: 1.0, + reason: '', + }); +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +describe('computeMRO', () => { + + // ---- C++ diamond -------------------------------------------------------- + describe('C++ diamond inheritance', () => { + it('leftmost base wins when both B and C override foo', () => { + // Diamond: A <- B, A <- C, B <- D, C <- D + const graph = createKnowledgeGraph(); + const aId = addClass(graph, 'A', 'cpp'); + const bId = addClass(graph, 'B', 'cpp'); + const cId = addClass(graph, 'C', 'cpp'); + const dId = addClass(graph, 'D', 'cpp'); + + addExtends(graph, 'B', 'A'); + addExtends(graph, 'C', 'A'); + addExtends(graph, 'D', 'B'); // B is leftmost + addExtends(graph, 'D', 'C'); + + // A has foo, B overrides foo, C overrides foo + addMethod(graph, 'A', 'foo'); + const bFoo = addMethod(graph, 'B', 'foo'); + const cFoo = addMethod(graph, 'C', 'foo'); + + const result = computeMRO(graph); + + // D should have an entry with ambiguity on foo + const dEntry = result.entries.find(e => e.className === 'D'); + expect(dEntry).toBeDefined(); + expect(dEntry!.language).toBe('cpp'); + + const fooAmbiguity = dEntry!.ambiguities.find(a => a.methodName === 'foo'); + expect(fooAmbiguity).toBeDefined(); + expect(fooAmbiguity!.definedIn.length).toBeGreaterThanOrEqual(2); + + // Leftmost base (B) wins + expect(fooAmbiguity!.resolvedTo).toBe(bFoo); + expect(fooAmbiguity!.reason).toContain('C++ leftmost'); + expect(fooAmbiguity!.reason).toContain('B'); + + // OVERRIDES edge emitted + expect(result.overrideEdges).toBeGreaterThanOrEqual(1); + const overrides = graph.relationships.filter(r => r.type === 'OVERRIDES'); + expect(overrides.some(r => r.sourceId === dId && r.targetId === bFoo)).toBe(true); + }); + + it('no ambiguity when foo only in A (diamond no override)', () => { + // Diamond: A <- B, A <- C, B <- D, C <- D, but only A has foo + const graph = createKnowledgeGraph(); + addClass(graph, 'A', 'cpp'); + addClass(graph, 'B', 'cpp'); + addClass(graph, 'C', 'cpp'); + addClass(graph, 'D', 'cpp'); + + addExtends(graph, 'B', 'A'); + addExtends(graph, 'C', 'A'); + addExtends(graph, 'D', 'B'); + addExtends(graph, 'D', 'C'); + + // Only A has foo + addMethod(graph, 'A', 'foo'); + + const result = computeMRO(graph); + + const dEntry = result.entries.find(e => e.className === 'D'); + expect(dEntry).toBeDefined(); + // A::foo appears only once across ancestors — no collision + // (B and C don't have their own foo, the duplicate is A::foo seen through both paths) + const fooAmbiguity = dEntry!.ambiguities.find(a => a.methodName === 'foo'); + expect(fooAmbiguity).toBeUndefined(); + }); + }); + + // ---- C# class + interface ----------------------------------------------- + describe('C# class + interface', () => { + it('class method beats interface default', () => { + const graph = createKnowledgeGraph(); + const classId = addClass(graph, 'MyClass', 'csharp'); + const baseId = addClass(graph, 'BaseClass', 'csharp'); + const ifaceId = addClass(graph, 'IDoSomething', 'csharp', 'Interface'); + + addExtends(graph, 'MyClass', 'BaseClass'); + addImplements(graph, 'MyClass', 'IDoSomething'); + + const baseDoIt = addMethod(graph, 'BaseClass', 'doIt'); + const ifaceDoIt = addMethod(graph, 'IDoSomething', 'doIt', 'Interface'); + + const result = computeMRO(graph); + + const entry = result.entries.find(e => e.className === 'MyClass'); + expect(entry).toBeDefined(); + + const doItAmbiguity = entry!.ambiguities.find(a => a.methodName === 'doIt'); + expect(doItAmbiguity).toBeDefined(); + // Class method wins + expect(doItAmbiguity!.resolvedTo).toBe(baseDoIt); + expect(doItAmbiguity!.reason).toContain('class method wins'); + }); + + it('multiple interface methods with same name are ambiguous', () => { + const graph = createKnowledgeGraph(); + addClass(graph, 'MyClass', 'csharp'); + addClass(graph, 'IFoo', 'csharp', 'Interface'); + addClass(graph, 'IBar', 'csharp', 'Interface'); + + addImplements(graph, 'MyClass', 'IFoo'); + addImplements(graph, 'MyClass', 'IBar'); + + addMethod(graph, 'IFoo', 'process', 'Interface'); + addMethod(graph, 'IBar', 'process', 'Interface'); + + const result = computeMRO(graph); + + const entry = result.entries.find(e => e.className === 'MyClass'); + expect(entry).toBeDefined(); + + const processAmbiguity = entry!.ambiguities.find(a => a.methodName === 'process'); + expect(processAmbiguity).toBeDefined(); + expect(processAmbiguity!.resolvedTo).toBeNull(); + expect(processAmbiguity!.reason).toContain('ambiguous'); + expect(result.ambiguityCount).toBeGreaterThanOrEqual(1); + }); + }); + + // ---- Python C3 ---------------------------------------------------------- + describe('Python C3 linearization', () => { + it('C3 order determines winner in diamond with overrides', () => { + // Diamond: A <- B, A <- C, B <- D, C <- D + // class D(B, C) → C3 MRO: B, C, A + const graph = createKnowledgeGraph(); + addClass(graph, 'A', 'python'); + addClass(graph, 'B', 'python'); + addClass(graph, 'C', 'python'); + const dId = addClass(graph, 'D', 'python'); + + addExtends(graph, 'B', 'A'); + addExtends(graph, 'C', 'A'); + addExtends(graph, 'D', 'B'); // B first → leftmost in C3 + addExtends(graph, 'D', 'C'); + + addMethod(graph, 'A', 'foo'); + const bFoo = addMethod(graph, 'B', 'foo'); + addMethod(graph, 'C', 'foo'); + + const result = computeMRO(graph); + + const dEntry = result.entries.find(e => e.className === 'D'); + expect(dEntry).toBeDefined(); + + const fooAmbiguity = dEntry!.ambiguities.find(a => a.methodName === 'foo'); + expect(fooAmbiguity).toBeDefined(); + // C3 linearization for D(B, C): B comes first + expect(fooAmbiguity!.resolvedTo).toBe(bFoo); + expect(fooAmbiguity!.reason).toContain('Python C3'); + }); + }); + + // ---- Java class + interface --------------------------------------------- + describe('Java class + interface', () => { + it('class method beats interface default', () => { + const graph = createKnowledgeGraph(); + addClass(graph, 'Service', 'java'); + addClass(graph, 'BaseService', 'java'); + addClass(graph, 'Runnable', 'java', 'Interface'); + + addExtends(graph, 'Service', 'BaseService'); + addImplements(graph, 'Service', 'Runnable'); + + const baseRun = addMethod(graph, 'BaseService', 'run'); + addMethod(graph, 'Runnable', 'run', 'Interface'); + + const result = computeMRO(graph); + + const entry = result.entries.find(e => e.className === 'Service'); + expect(entry).toBeDefined(); + + const runAmbiguity = entry!.ambiguities.find(a => a.methodName === 'run'); + expect(runAmbiguity).toBeDefined(); + expect(runAmbiguity!.resolvedTo).toBe(baseRun); + expect(runAmbiguity!.reason).toContain('class method wins'); + }); + }); + + // ---- Rust trait conflicts ----------------------------------------------- + describe('Rust trait conflicts', () => { + it('trait conflicts result in null resolution with qualified syntax reason', () => { + const graph = createKnowledgeGraph(); + addClass(graph, 'MyStruct', 'rust', 'Struct'); + addClass(graph, 'TraitA', 'rust', 'Trait'); + addClass(graph, 'TraitB', 'rust', 'Trait'); + + addImplements(graph, 'MyStruct', 'TraitA', 'Struct', 'Trait'); + addImplements(graph, 'MyStruct', 'TraitB', 'Struct', 'Trait'); + + addMethod(graph, 'TraitA', 'execute', 'Trait'); + addMethod(graph, 'TraitB', 'execute', 'Trait'); + + const result = computeMRO(graph); + + const entry = result.entries.find(e => e.className === 'MyStruct'); + expect(entry).toBeDefined(); + + const execAmbiguity = entry!.ambiguities.find(a => a.methodName === 'execute'); + expect(execAmbiguity).toBeDefined(); + expect(execAmbiguity!.resolvedTo).toBeNull(); + expect(execAmbiguity!.reason).toContain('qualified syntax'); + expect(result.ambiguityCount).toBeGreaterThanOrEqual(1); + + // No OVERRIDES edge emitted for Rust ambiguity + const overrides = graph.relationships.filter( + r => r.type === 'OVERRIDES' && r.sourceId === generateId('Struct', 'MyStruct') + ); + expect(overrides).toHaveLength(0); + }); + }); + + // ---- Property collisions don't trigger OVERRIDES ------------------------ + describe('Property nodes excluded from OVERRIDES', () => { + it('property name collision across parents does not emit OVERRIDES edge', () => { + const graph = createKnowledgeGraph(); + const parentA = addClass(graph, 'ParentA', 'typescript'); + const parentB = addClass(graph, 'ParentB', 'typescript'); + const child = addClass(graph, 'Child', 'typescript'); + + addExtends(graph, 'Child', 'ParentA'); + addExtends(graph, 'Child', 'ParentB'); + + // Add Property nodes (same name 'name') to both parents via HAS_PROPERTY + const propA = generateId('Property', 'ParentA.name'); + graph.addNode({ id: propA, label: 'Property', properties: { name: 'name', filePath: 'src/ParentA.ts' } }); + graph.addRelationship({ + id: generateId('HAS_PROPERTY', `${parentA}->${propA}`), + sourceId: parentA, targetId: propA, type: 'HAS_PROPERTY', confidence: 1.0, reason: '', + }); + + const propB = generateId('Property', 'ParentB.name'); + graph.addNode({ id: propB, label: 'Property', properties: { name: 'name', filePath: 'src/ParentB.ts' } }); + graph.addRelationship({ + id: generateId('HAS_PROPERTY', `${parentB}->${propB}`), + sourceId: parentB, targetId: propB, type: 'HAS_PROPERTY', confidence: 1.0, reason: '', + }); + + const result = computeMRO(graph); + + // No OVERRIDES edge should be emitted for properties + const overrides = graph.relationships.filter(r => r.type === 'OVERRIDES'); + expect(overrides).toHaveLength(0); + expect(result.overrideEdges).toBe(0); + }); + + it('method collision still triggers OVERRIDES even when properties also collide', () => { + const graph = createKnowledgeGraph(); + const parentA = addClass(graph, 'PA', 'cpp'); + const parentB = addClass(graph, 'PB', 'cpp'); + addClass(graph, 'Ch', 'cpp'); + + addExtends(graph, 'Ch', 'PA'); + addExtends(graph, 'Ch', 'PB'); + + // Method collision (should trigger OVERRIDES) + const methodA = addMethod(graph, 'PA', 'doWork'); + addMethod(graph, 'PB', 'doWork'); + + // Property collision (should NOT trigger OVERRIDES — properties use HAS_PROPERTY, not HAS_METHOD) + const propA = generateId('Property', 'PA.id'); + graph.addNode({ id: propA, label: 'Property', properties: { name: 'id', filePath: 'src/PA.ts' } }); + graph.addRelationship({ + id: generateId('HAS_PROPERTY', `${parentA}->${propA}`), + sourceId: parentA, targetId: propA, type: 'HAS_PROPERTY', confidence: 1.0, reason: '', + }); + + const propB = generateId('Property', 'PB.id'); + graph.addNode({ id: propB, label: 'Property', properties: { name: 'id', filePath: 'src/PB.ts' } }); + graph.addRelationship({ + id: generateId('HAS_PROPERTY', `${parentB}->${propB}`), + sourceId: parentB, targetId: propB, type: 'HAS_PROPERTY', confidence: 1.0, reason: '', + }); + + const result = computeMRO(graph); + + // Only 1 OVERRIDES edge (for the method, not the property) + const overrides = graph.relationships.filter(r => r.type === 'OVERRIDES'); + expect(overrides).toHaveLength(1); + expect(overrides[0].targetId).toBe(methodA); // leftmost base wins for C++ + expect(result.overrideEdges).toBe(1); + }); + }); + + // ---- No ambiguity: single parent ---------------------------------------- + describe('single parent, no ambiguity', () => { + it('single parent with unique methods produces no ambiguities', () => { + const graph = createKnowledgeGraph(); + addClass(graph, 'Parent', 'typescript'); + addClass(graph, 'Child', 'typescript'); + + addExtends(graph, 'Child', 'Parent'); + + addMethod(graph, 'Parent', 'foo'); + addMethod(graph, 'Parent', 'bar'); + + const result = computeMRO(graph); + + const entry = result.entries.find(e => e.className === 'Child'); + expect(entry).toBeDefined(); + expect(entry!.ambiguities).toHaveLength(0); + }); + }); + + // ---- No parents: standalone class not in entries ------------------------ + describe('standalone class', () => { + it('class with no parents is not included in entries', () => { + const graph = createKnowledgeGraph(); + addClass(graph, 'Standalone', 'typescript'); + addMethod(graph, 'Standalone', 'doStuff'); + + const result = computeMRO(graph); + + const entry = result.entries.find(e => e.className === 'Standalone'); + expect(entry).toBeUndefined(); + expect(result.overrideEdges).toBe(0); + expect(result.ambiguityCount).toBe(0); + }); + }); + + // ---- Own method shadows ancestor ---------------------------------------- + describe('own method shadows ancestor', () => { + it('class defining its own method suppresses ambiguity', () => { + const graph = createKnowledgeGraph(); + addClass(graph, 'Base1', 'cpp'); + addClass(graph, 'Base2', 'cpp'); + addClass(graph, 'Child', 'cpp'); + + addExtends(graph, 'Child', 'Base1'); + addExtends(graph, 'Child', 'Base2'); + + addMethod(graph, 'Base1', 'foo'); + addMethod(graph, 'Base2', 'foo'); + addMethod(graph, 'Child', 'foo'); // own method + + const result = computeMRO(graph); + + const entry = result.entries.find(e => e.className === 'Child'); + expect(entry).toBeDefined(); + // No ambiguity because Child defines its own foo + const fooAmbiguity = entry!.ambiguities.find(a => a.methodName === 'foo'); + expect(fooAmbiguity).toBeUndefined(); + }); + }); + + // ---- Empty graph -------------------------------------------------------- + describe('empty graph', () => { + it('returns empty result for graph with no classes', () => { + const graph = createKnowledgeGraph(); + const result = computeMRO(graph); + expect(result.entries).toHaveLength(0); + expect(result.overrideEdges).toBe(0); + expect(result.ambiguityCount).toBe(0); + }); + }); + + // ---- Cyclic inheritance (P1 fix) ---------------------------------------- + describe('cyclic inheritance', () => { + it('does not stack overflow on cyclic Python hierarchy', () => { + // A extends B, B extends A — cyclic + const graph = createKnowledgeGraph(); + addClass(graph, 'A', 'python'); + addClass(graph, 'B', 'python'); + addExtends(graph, 'A', 'B'); + addExtends(graph, 'B', 'A'); + addMethod(graph, 'A', 'foo'); + addMethod(graph, 'B', 'foo'); + + // Should NOT throw — c3Linearize returns null, falls back to BFS + const result = computeMRO(graph); + expect(result).toBeDefined(); + // Both A and B have parents, so both get entries + expect(result.entries.length).toBeGreaterThanOrEqual(1); + }); + + it('handles 3-node cycle gracefully', () => { + // A → B → C → A + const graph = createKnowledgeGraph(); + addClass(graph, 'X', 'python'); + addClass(graph, 'Y', 'python'); + addClass(graph, 'Z', 'python'); + addExtends(graph, 'X', 'Y'); + addExtends(graph, 'Y', 'Z'); + addExtends(graph, 'Z', 'X'); + + const result = computeMRO(graph); + expect(result).toBeDefined(); + }); + }); +}); diff --git a/gitnexus/test/unit/named-binding-extraction.test.ts b/gitnexus/test/unit/named-binding-extraction.test.ts new file mode 100644 index 0000000000..3c66984d0b --- /dev/null +++ b/gitnexus/test/unit/named-binding-extraction.test.ts @@ -0,0 +1,82 @@ +import { describe, it, expect } from 'vitest'; +import { extractCsharpNamedBindings } from '../../src/core/ingestion/named-binding-extraction.js'; +import Parser from 'tree-sitter'; +import CSharp from 'tree-sitter-c-sharp'; + +const parser = new Parser(); + +/** Walk a tree depth-first and return the first node matching the given type. */ +function findFirst(node: any, type: string): any | undefined { + if (node.type === type) return node; + for (let i = 0; i < node.childCount; i++) { + const found = findFirst(node.child(i), type); + if (found) return found; + } + return undefined; +} + +const parse = (code: string) => { + parser.setLanguage(CSharp); + return parser.parse(code); +}; + +describe('extractCsharpNamedBindings', () => { + describe('non-aliased namespace imports (known limitation)', () => { + it('returns undefined for non-aliased namespace imports (known limitation)', () => { + // C# using Namespace imports can't be reduced to per-symbol bindings without type + // inference — resolution falls back to PackageMap directory matching. + const tree = parse('using MyApp.Models;'); + const usingNode = findFirst(tree.rootNode, 'using_directive'); + expect(usingNode).toBeDefined(); + + const result = extractCsharpNamedBindings(usingNode); + + expect(result).toBeUndefined(); + }); + + it('returns undefined for a single-segment non-aliased import', () => { + // C# using Namespace imports can't be reduced to per-symbol bindings without type + // inference — resolution falls back to PackageMap directory matching. + const tree = parse('using System;'); + const usingNode = findFirst(tree.rootNode, 'using_directive'); + expect(usingNode).toBeDefined(); + + const result = extractCsharpNamedBindings(usingNode); + + expect(result).toBeUndefined(); + }); + }); + + describe('aliased imports', () => { + it('returns a binding for a simple aliased import', () => { + const tree = parse('using Mod = MyApp.Models;'); + const usingNode = findFirst(tree.rootNode, 'using_directive'); + expect(usingNode).toBeDefined(); + + const result = extractCsharpNamedBindings(usingNode); + + expect(result).toEqual([{ local: 'Mod', exported: 'Models' }]); + }); + + it('uses the last segment of the qualified name as the exported binding', () => { + const tree = parse('using Svc = MyApp.Services.UserService;'); + const usingNode = findFirst(tree.rootNode, 'using_directive'); + expect(usingNode).toBeDefined(); + + const result = extractCsharpNamedBindings(usingNode); + + expect(result).toEqual([{ local: 'Svc', exported: 'UserService' }]); + }); + }); + + describe('edge cases', () => { + it('returns undefined when the node type is not using_directive', () => { + // Passing a synthetic object that is not a using_directive node. + const fakeNode = { type: 'import_declaration', namedChildCount: 0 }; + + const result = extractCsharpNamedBindings(fakeNode); + + expect(result).toBeUndefined(); + }); + }); +}); diff --git a/gitnexus/test/unit/parser-loader.test.ts b/gitnexus/test/unit/parser-loader.test.ts new file mode 100644 index 0000000000..11e747f403 --- /dev/null +++ b/gitnexus/test/unit/parser-loader.test.ts @@ -0,0 +1,91 @@ +import { describe, it, expect } from 'vitest'; +import { loadParser, loadLanguage } from '../../src/core/tree-sitter/parser-loader.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; + +describe('parser-loader', () => { + describe('loadParser', () => { + it('returns a Parser instance', async () => { + const parser = await loadParser(); + expect(parser).toBeDefined(); + expect(typeof parser.parse).toBe('function'); + }); + + it('returns the same singleton instance', async () => { + const parser1 = await loadParser(); + const parser2 = await loadParser(); + expect(parser1).toBe(parser2); + }); + }); + + describe('loadLanguage', () => { + it('loads TypeScript language', async () => { + await expect(loadLanguage(SupportedLanguages.TypeScript)).resolves.not.toThrow(); + }); + + it('loads JavaScript language', async () => { + await expect(loadLanguage(SupportedLanguages.JavaScript)).resolves.not.toThrow(); + }); + + it('loads Python language', async () => { + await expect(loadLanguage(SupportedLanguages.Python)).resolves.not.toThrow(); + }); + + it('loads Java language', async () => { + await expect(loadLanguage(SupportedLanguages.Java)).resolves.not.toThrow(); + }); + + it('loads C language', async () => { + await expect(loadLanguage(SupportedLanguages.C)).resolves.not.toThrow(); + }); + + it('loads C++ language', async () => { + await expect(loadLanguage(SupportedLanguages.CPlusPlus)).resolves.not.toThrow(); + }); + + it('loads C# language', async () => { + await expect(loadLanguage(SupportedLanguages.CSharp)).resolves.not.toThrow(); + }); + + it('loads Go language', async () => { + await expect(loadLanguage(SupportedLanguages.Go)).resolves.not.toThrow(); + }); + + it('loads Rust language', async () => { + await expect(loadLanguage(SupportedLanguages.Rust)).resolves.not.toThrow(); + }); + + it('loads PHP language', async () => { + await expect(loadLanguage(SupportedLanguages.PHP)).resolves.not.toThrow(); + }); + + it('loads TSX grammar for .tsx files', async () => { + // TSX uses a different grammar (TypeScript.tsx vs TypeScript.typescript) + await expect(loadLanguage(SupportedLanguages.TypeScript, 'Component.tsx')).resolves.not.toThrow(); + }); + + it('loads TS grammar for .ts files', async () => { + await expect(loadLanguage(SupportedLanguages.TypeScript, 'utils.ts')).resolves.not.toThrow(); + }); + + it('loads Ruby language', async () => { + await expect(loadLanguage(SupportedLanguages.Ruby)).resolves.not.toThrow(); + }); + + it('throws for unsupported language', async () => { + await expect(loadLanguage('erlang' as SupportedLanguages)).rejects.toThrow('Unsupported language'); + }); + }); + + describe('Swift optional dependency', () => { + it('handles Swift loading gracefully', async () => { + // Swift is optional — it either loads successfully or throws an error about unsupported language + try { + await loadLanguage(SupportedLanguages.Swift); + // If it succeeds, tree-sitter-swift is installed + } catch (e: any) { + // If it fails, it should be because tree-sitter-swift is not installed + expect(e.message).toContain('Unsupported language'); + } + }); + }); +}); diff --git a/gitnexus/test/unit/pipeline-exports.test.ts b/gitnexus/test/unit/pipeline-exports.test.ts new file mode 100644 index 0000000000..a2d37ffeab --- /dev/null +++ b/gitnexus/test/unit/pipeline-exports.test.ts @@ -0,0 +1,8 @@ +import { describe, it, expect } from 'vitest'; +import { runPipelineFromRepo } from '../../src/core/ingestion/pipeline.js'; + +describe('pipeline', () => { + it('exports runPipelineFromRepo function', () => { + expect(typeof runPipelineFromRepo).toBe('function'); + }); +}); diff --git a/gitnexus/test/unit/process-processor.test.ts b/gitnexus/test/unit/process-processor.test.ts new file mode 100644 index 0000000000..5a09083f03 --- /dev/null +++ b/gitnexus/test/unit/process-processor.test.ts @@ -0,0 +1,361 @@ +import { describe, it, expect, vi } from 'vitest'; +import { processProcesses, type ProcessDetectionConfig } from '../../src/core/ingestion/process-processor.js'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import type { CommunityMembership } from '../../src/core/ingestion/community-processor.js'; + +describe('processProcesses', () => { + it('detects no processes in empty graph', async () => { + const graph = createKnowledgeGraph(); + const result = await processProcesses(graph, []); + expect(result.processes).toHaveLength(0); + expect(result.steps).toHaveLength(0); + expect(result.stats.totalProcesses).toBe(0); + expect(result.stats.entryPointsFound).toBe(0); + expect(result.stats.avgStepCount).toBe(0); + }); + + it('detects no processes when there are no CALLS relationships', async () => { + const graph = createKnowledgeGraph(); + graph.addNode({ + id: 'func:main', label: 'Function', + properties: { name: 'main', filePath: 'src/index.ts', startLine: 1, endLine: 10, isExported: true } + }); + + const result = await processProcesses(graph, []); + expect(result.processes).toHaveLength(0); + }); + + it('detects a simple 3-step process with correct structure', async () => { + const graph = createKnowledgeGraph(); + + // Create 3 functions in a chain + graph.addNode({ + id: 'func:handleRequest', label: 'Function', + properties: { name: 'handleRequest', filePath: 'src/handler.ts', startLine: 1, endLine: 10, isExported: true } + }); + graph.addNode({ + id: 'func:validateInput', label: 'Function', + properties: { name: 'validateInput', filePath: 'src/validator.ts', startLine: 1, endLine: 5, isExported: true } + }); + graph.addNode({ + id: 'func:saveToDb', label: 'Function', + properties: { name: 'saveToDb', filePath: 'src/db.ts', startLine: 1, endLine: 8, isExported: true } + }); + + // handleRequest -> validateInput -> saveToDb + graph.addRelationship({ + id: 'call:1', sourceId: 'func:handleRequest', targetId: 'func:validateInput', + type: 'CALLS', confidence: 0.9, reason: 'import-resolved' + }); + graph.addRelationship({ + id: 'call:2', sourceId: 'func:validateInput', targetId: 'func:saveToDb', + type: 'CALLS', confidence: 0.9, reason: 'import-resolved' + }); + + const memberships: CommunityMembership[] = [ + { nodeId: 'func:handleRequest', communityId: 'community:0' }, + { nodeId: 'func:validateInput', communityId: 'community:0' }, + { nodeId: 'func:saveToDb', communityId: 'community:0' }, + ]; + + const result = await processProcesses(graph, memberships); + + // Must detect at least one process + expect(result.processes.length).toBeGreaterThan(0); + + // Find the process starting from handleRequest + const process = result.processes.find(p => p.entryPointId === 'func:handleRequest'); + expect(process).toBeDefined(); + expect(process!.stepCount).toBe(3); + expect(process!.entryPointId).toBe('func:handleRequest'); + expect(process!.terminalId).toBe('func:saveToDb'); + expect(process!.processType).toBe('intra_community'); + expect(process!.communities).toEqual(['community:0']); + + // Verify trace order: entry -> middle -> terminal + expect(process!.trace).toEqual([ + 'func:handleRequest', + 'func:validateInput', + 'func:saveToDb', + ]); + + // Verify steps are 1-indexed and in correct order + const processSteps = result.steps.filter(s => s.processId === process!.id); + expect(processSteps).toHaveLength(3); + expect(processSteps[0]).toEqual(expect.objectContaining({ nodeId: 'func:handleRequest', step: 1 })); + expect(processSteps[1]).toEqual(expect.objectContaining({ nodeId: 'func:validateInput', step: 2 })); + expect(processSteps[2]).toEqual(expect.objectContaining({ nodeId: 'func:saveToDb', step: 3 })); + + // Verify label is generated from entry and terminal names + expect(process!.heuristicLabel).toContain('HandleRequest'); + expect(process!.heuristicLabel).toContain('SaveToDb'); + + // Stats should reflect the detected processes + expect(result.stats.totalProcesses).toBe(result.processes.length); + expect(result.stats.entryPointsFound).toBeGreaterThan(0); + }); + + it('respects maxTraceDepth config', async () => { + const graph = createKnowledgeGraph(); + + // Create a long chain: f0 -> f1 -> f2 -> f3 -> f4 + for (let i = 0; i < 5; i++) { + graph.addNode({ + id: `func:f${i}`, label: 'Function', + properties: { name: `f${i}`, filePath: `src/f${i}.ts`, startLine: 1, endLine: 5, isExported: true } + }); + } + for (let i = 0; i < 4; i++) { + graph.addRelationship({ + id: `call:${i}`, sourceId: `func:f${i}`, targetId: `func:f${i+1}`, + type: 'CALLS', confidence: 0.9, reason: '' + }); + } + + const memberships: CommunityMembership[] = Array.from({ length: 5 }, (_, i) => ({ + nodeId: `func:f${i}`, communityId: 'community:0' + })); + + // Limit to 3 steps max depth + const config: Partial<ProcessDetectionConfig> = { maxTraceDepth: 3 }; + const result = await processProcesses(graph, memberships, undefined, config); + + // Should still find processes, but each trace should be at most maxTraceDepth steps + expect(result.processes.length).toBeGreaterThan(0); + for (const process of result.processes) { + expect(process.stepCount).toBeLessThanOrEqual(3); + } + }); + + it('detects cross_community processes', async () => { + const graph = createKnowledgeGraph(); + + graph.addNode({ + id: 'func:apiHandler', label: 'Function', + properties: { name: 'apiHandler', filePath: 'src/api/handler.ts', startLine: 1, endLine: 10, isExported: true } + }); + graph.addNode({ + id: 'func:dbQuery', label: 'Function', + properties: { name: 'dbQuery', filePath: 'src/db/query.ts', startLine: 1, endLine: 5, isExported: true } + }); + graph.addNode({ + id: 'func:formatResponse', label: 'Function', + properties: { name: 'formatResponse', filePath: 'src/api/format.ts', startLine: 1, endLine: 5, isExported: true } + }); + + // apiHandler -> dbQuery (cross community), apiHandler -> formatResponse (same community) + graph.addRelationship({ + id: 'call:1', sourceId: 'func:apiHandler', targetId: 'func:dbQuery', + type: 'CALLS', confidence: 0.9, reason: '' + }); + graph.addRelationship({ + id: 'call:2', sourceId: 'func:dbQuery', targetId: 'func:formatResponse', + type: 'CALLS', confidence: 0.9, reason: '' + }); + + // Put them in different communities + const memberships: CommunityMembership[] = [ + { nodeId: 'func:apiHandler', communityId: 'community:api' }, + { nodeId: 'func:dbQuery', communityId: 'community:db' }, + { nodeId: 'func:formatResponse', communityId: 'community:api' }, + ]; + + const result = await processProcesses(graph, memberships); + + // Must find at least one process + expect(result.processes.length).toBeGreaterThan(0); + + // The process from apiHandler should be cross_community (touches api + db communities) + const crossProcess = result.processes.find(p => p.entryPointId === 'func:apiHandler'); + expect(crossProcess).toBeDefined(); + expect(crossProcess!.processType).toBe('cross_community'); + expect(crossProcess!.communities.length).toBeGreaterThan(1); + expect(crossProcess!.communities).toContain('community:api'); + expect(crossProcess!.communities).toContain('community:db'); + + // Stats should count cross-community + expect(result.stats.crossCommunityCount).toBeGreaterThan(0); + }); + + it('excludes test files from entry points', async () => { + const graph = createKnowledgeGraph(); + + // Test file function + graph.addNode({ + id: 'func:testMain', label: 'Function', + properties: { name: 'testMain', filePath: 'test/unit/main.test.ts', startLine: 1, endLine: 10, isExported: true } + }); + graph.addNode({ + id: 'func:helper', label: 'Function', + properties: { name: 'helper', filePath: 'src/helper.ts', startLine: 1, endLine: 5, isExported: true } + }); + + graph.addRelationship({ + id: 'call:1', sourceId: 'func:testMain', targetId: 'func:helper', + type: 'CALLS', confidence: 0.9, reason: '' + }); + + const result = await processProcesses(graph, []); + + // Test files should not be used as entry points + const testProcess = result.processes.find(p => p.entryPointId === 'func:testMain'); + expect(testProcess).toBeUndefined(); + }); + + it('filters out low-confidence calls (below 0.5)', async () => { + const graph = createKnowledgeGraph(); + + graph.addNode({ + id: 'func:a', label: 'Function', + properties: { name: 'a', filePath: 'src/a.ts', startLine: 1, endLine: 5, isExported: true } + }); + graph.addNode({ + id: 'func:b', label: 'Function', + properties: { name: 'b', filePath: 'src/b.ts', startLine: 1, endLine: 5, isExported: true } + }); + graph.addNode({ + id: 'func:c', label: 'Function', + properties: { name: 'c', filePath: 'src/c.ts', startLine: 1, endLine: 5, isExported: true } + }); + + // a -> b with low confidence (fuzzy-global ambiguous), a -> c with high confidence + graph.addRelationship({ + id: 'call:1', sourceId: 'func:a', targetId: 'func:b', + type: 'CALLS', confidence: 0.3, reason: 'fuzzy-global' + }); + graph.addRelationship({ + id: 'call:2', sourceId: 'func:a', targetId: 'func:c', + type: 'CALLS', confidence: 0.9, reason: 'import-resolved' + }); + + const result = await processProcesses(graph, []); + + // No process should include func:b since the edge has confidence < 0.5 (MIN_TRACE_CONFIDENCE) + for (const process of result.processes) { + expect(process.trace).not.toContain('func:b'); + } + }); + + it('handles cycles without infinite loops', async () => { + const graph = createKnowledgeGraph(); + + graph.addNode({ + id: 'func:a', label: 'Function', + properties: { name: 'processItem', filePath: 'src/a.ts', startLine: 1, endLine: 5, isExported: true } + }); + graph.addNode({ + id: 'func:b', label: 'Function', + properties: { name: 'validate', filePath: 'src/b.ts', startLine: 1, endLine: 5, isExported: true } + }); + graph.addNode({ + id: 'func:c', label: 'Function', + properties: { name: 'retry', filePath: 'src/c.ts', startLine: 1, endLine: 5, isExported: true } + }); + + // a -> b -> c -> a (cycle) + graph.addRelationship({ + id: 'call:1', sourceId: 'func:a', targetId: 'func:b', + type: 'CALLS', confidence: 0.9, reason: '' + }); + graph.addRelationship({ + id: 'call:2', sourceId: 'func:b', targetId: 'func:c', + type: 'CALLS', confidence: 0.9, reason: '' + }); + graph.addRelationship({ + id: 'call:3', sourceId: 'func:c', targetId: 'func:a', + type: 'CALLS', confidence: 0.9, reason: '' + }); + + const memberships: CommunityMembership[] = [ + { nodeId: 'func:a', communityId: 'community:0' }, + { nodeId: 'func:b', communityId: 'community:0' }, + { nodeId: 'func:c', communityId: 'community:0' }, + ]; + + // Should complete without hanging, and traces should not repeat nodes + const result = await processProcesses(graph, memberships); + for (const process of result.processes) { + const uniqueNodes = new Set(process.trace); + expect(uniqueNodes.size).toBe(process.trace.length); + } + }); + + it('respects minSteps default (3) — rejects 2-step traces', async () => { + const graph = createKnowledgeGraph(); + + // Only 2 functions: a -> b (2 steps, below default minSteps of 3) + graph.addNode({ + id: 'func:caller', label: 'Function', + properties: { name: 'caller', filePath: 'src/caller.ts', startLine: 1, endLine: 5, isExported: true } + }); + graph.addNode({ + id: 'func:callee', label: 'Function', + properties: { name: 'callee', filePath: 'src/callee.ts', startLine: 1, endLine: 5, isExported: true } + }); + + graph.addRelationship({ + id: 'call:1', sourceId: 'func:caller', targetId: 'func:callee', + type: 'CALLS', confidence: 0.9, reason: '' + }); + + const result = await processProcesses(graph, []); + + // Default minSteps is 3, so a 2-step trace (caller -> callee) should be rejected + expect(result.processes).toHaveLength(0); + }); + + it('calls progress callback with messages', async () => { + const graph = createKnowledgeGraph(); + const onProgress = vi.fn(); + + await processProcesses(graph, [], onProgress); + + expect(onProgress).toHaveBeenCalled(); + // Verify callback receives (message: string, progress: number) + const [message, progress] = onProgress.mock.calls[0]; + expect(typeof message).toBe('string'); + expect(typeof progress).toBe('number'); + expect(progress).toBeGreaterThanOrEqual(0); + expect(progress).toBeLessThanOrEqual(100); + }); + + it('limits output to maxProcesses', async () => { + const graph = createKnowledgeGraph(); + + // Create many independent 3-step chains to generate many processes + for (let chain = 0; chain < 10; chain++) { + for (let step = 0; step < 3; step++) { + graph.addNode({ + id: `func:chain${chain}_f${step}`, label: 'Function', + properties: { + name: `chain${chain}_f${step}`, + filePath: `src/chain${chain}/f${step}.ts`, + startLine: 1, endLine: 5, + isExported: true + } + }); + } + for (let step = 0; step < 2; step++) { + graph.addRelationship({ + id: `call:chain${chain}_${step}`, + sourceId: `func:chain${chain}_f${step}`, + targetId: `func:chain${chain}_f${step+1}`, + type: 'CALLS', confidence: 0.9, reason: '' + }); + } + } + + const memberships: CommunityMembership[] = []; + for (let chain = 0; chain < 10; chain++) { + for (let step = 0; step < 3; step++) { + memberships.push({ nodeId: `func:chain${chain}_f${step}`, communityId: 'community:0' }); + } + } + + const config: Partial<ProcessDetectionConfig> = { maxProcesses: 3 }; + const result = await processProcesses(graph, memberships, undefined, config); + + expect(result.processes.length).toBeLessThanOrEqual(3); + expect(result.stats.totalProcesses).toBeLessThanOrEqual(3); + }); +}); diff --git a/gitnexus/test/unit/repo-manager.test.ts b/gitnexus/test/unit/repo-manager.test.ts new file mode 100644 index 0000000000..24582af57e --- /dev/null +++ b/gitnexus/test/unit/repo-manager.test.ts @@ -0,0 +1,136 @@ +/** + * P1 Unit Tests: Repository Manager + * + * Tests: getStoragePath, getStoragePaths, readRegistry, registerRepo, unregisterRepo + * Covers hardening fixes #29 (API key file permissions) and #30 (case-insensitive paths on Windows) + */ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import path from 'path'; +import os from 'os'; +import fs from 'fs/promises'; +import { + getStoragePath, + getStoragePaths, + readRegistry, + saveCLIConfig, + loadCLIConfig, +} from '../../src/storage/repo-manager.js'; +import { createTempDir } from '../helpers/test-db.js'; + +// ─── getStoragePath ────────────────────────────────────────────────── + +describe('getStoragePath', () => { + it('appends .gitnexus to resolved repo path', () => { + const result = getStoragePath('/home/user/project'); + expect(result).toContain('.gitnexus'); + expect(path.basename(result)).toBe('.gitnexus'); + }); + + it('resolves relative paths', () => { + const result = getStoragePath('.'); + // Should be an absolute path + expect(path.isAbsolute(result)).toBe(true); + }); +}); + +// ─── getStoragePaths ───────────────────────────────────────────────── + +describe('getStoragePaths', () => { + it('returns storagePath, lbugPath, metaPath', () => { + const paths = getStoragePaths('/home/user/project'); + expect(paths.storagePath).toContain('.gitnexus'); + expect(paths.lbugPath).toContain('lbug'); + expect(paths.metaPath).toContain('meta.json'); + }); + + it('all paths are under storagePath', () => { + const paths = getStoragePaths('/home/user/project'); + expect(paths.lbugPath.startsWith(paths.storagePath)).toBe(true); + expect(paths.metaPath.startsWith(paths.storagePath)).toBe(true); + }); +}); + +// ─── readRegistry ──────────────────────────────────────────────────── + +describe('readRegistry', () => { + it('returns empty array when registry does not exist', async () => { + // readRegistry reads from ~/.gitnexus/registry.json + // If the file doesn't exist, it should return [] + // This test exercises the catch path + const result = await readRegistry(); + // Result is an array (may or may not be empty depending on user's system) + expect(Array.isArray(result)).toBe(true); + }); +}); + +// ─── CLI Config (file permissions) ─────────────────────────────────── + +describe('saveCLIConfig / loadCLIConfig', () => { + let tmpHandle: Awaited<ReturnType<typeof createTempDir>>; + let originalHomedir: typeof os.homedir; + + beforeEach(async () => { + tmpHandle = await createTempDir('gitnexus-config-test-'); + originalHomedir = os.homedir; + // Mock os.homedir to point to our temp dir + // Note: This won't fully work because repo-manager uses its own import of os + // We'll test what we can. + }); + + afterEach(async () => { + os.homedir = originalHomedir; + await tmpHandle.cleanup(); + }); + + it('loadCLIConfig returns empty object when config does not exist', async () => { + const config = await loadCLIConfig(); + // Returns {} or existing config + expect(typeof config).toBe('object'); + }); +}); + +// ─── Case-insensitive path comparison (Windows hardening #30) ──────── + +describe('case-insensitive path comparison', () => { + it('registerRepo uses case-insensitive compare on Windows', () => { + // The fix is in registerRepo: process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() + // We verify the logic inline since we can't easily mock process.platform + + const compareWindows = (a: string, b: string): boolean => { + return a.toLowerCase() === b.toLowerCase(); + }; + + // On Windows, these should match + expect(compareWindows('D:\\Projects\\MyApp', 'd:\\projects\\myapp')).toBe(true); + expect(compareWindows('C:\\Users\\USER\\project', 'c:\\users\\user\\project')).toBe(true); + + // Different paths should not match + expect(compareWindows('D:\\Projects\\App1', 'D:\\Projects\\App2')).toBe(false); + }); + + it('case-sensitive compare for non-Windows', () => { + const compareUnix = (a: string, b: string): boolean => { + return a === b; + }; + + // On Unix, case matters + expect(compareUnix('/home/user/Project', '/home/user/project')).toBe(false); + expect(compareUnix('/home/user/project', '/home/user/project')).toBe(true); + }); +}); + +// ─── API key file permissions (hardening #29) ──────────────────────── + +describe('API key file permissions', () => { + it('saveCLIConfig calls chmod 0o600 on non-Windows', async () => { + // We verify that the saveCLIConfig code has the chmod call + // by reading the source and checking statically. + // The actual chmod behavior is platform-dependent. + const source = await fs.readFile( + path.join(process.cwd(), 'src', 'storage', 'repo-manager.ts'), + 'utf-8', + ); + expect(source).toContain('chmod(configPath, 0o600)'); + expect(source).toContain("process.platform !== 'win32'"); + }); +}); diff --git a/gitnexus/test/unit/resources.test.ts b/gitnexus/test/unit/resources.test.ts new file mode 100644 index 0000000000..f3c3254fd8 --- /dev/null +++ b/gitnexus/test/unit/resources.test.ts @@ -0,0 +1,296 @@ +/** + * Unit Tests: MCP Resources + * + * Tests: getResourceDefinitions, getResourceTemplates, readResource + * - Static resource definitions + * - Dynamic resource templates + * - URI parsing and dispatch + * - Error handling for invalid URIs + * - Resource handlers with mocked backend + */ +import { describe, it, expect, vi } from 'vitest'; +import { + getResourceDefinitions, + getResourceTemplates, + readResource, +} from '../../src/mcp/resources.js'; + +// ─── Minimal mock backend ────────────────────────────────────────── + +function createMockBackend(overrides: Partial<Record<string, any>> = {}): any { + return { + listRepos: vi.fn().mockResolvedValue(overrides.repos ?? []), + resolveRepo: vi.fn().mockResolvedValue(overrides.resolvedRepo ?? { + name: 'test-repo', + repoPath: '/tmp/test-repo', + lastCommit: 'abc1234', + }), + getContext: vi.fn().mockReturnValue(overrides.context ?? null), + queryClusters: vi.fn().mockResolvedValue(overrides.clusters ?? { clusters: [] }), + queryProcesses: vi.fn().mockResolvedValue(overrides.processes ?? { processes: [] }), + queryClusterDetail: vi.fn().mockResolvedValue(overrides.clusterDetail ?? { error: 'Not found' }), + queryProcessDetail: vi.fn().mockResolvedValue(overrides.processDetail ?? { error: 'Not found' }), + ...overrides, + }; +} + +// ─── Static definitions ───────────────────────────────────────────── + +describe('getResourceDefinitions', () => { + it('returns 2 static resources', () => { + const defs = getResourceDefinitions(); + expect(defs).toHaveLength(2); + }); + + it('includes repos resource', () => { + const defs = getResourceDefinitions(); + const repos = defs.find(d => d.uri === 'gitnexus://repos'); + expect(repos).toBeDefined(); + expect(repos!.mimeType).toBe('text/yaml'); + }); + + it('includes setup resource', () => { + const defs = getResourceDefinitions(); + const setup = defs.find(d => d.uri === 'gitnexus://setup'); + expect(setup).toBeDefined(); + expect(setup!.mimeType).toBe('text/markdown'); + }); + + it('each definition has uri, name, description, mimeType', () => { + for (const def of getResourceDefinitions()) { + expect(def.uri).toBeTruthy(); + expect(def.name).toBeTruthy(); + expect(def.description).toBeTruthy(); + expect(def.mimeType).toBeTruthy(); + } + }); +}); + +describe('getResourceTemplates', () => { + it('returns 6 dynamic templates', () => { + const templates = getResourceTemplates(); + expect(templates).toHaveLength(6); + }); + + it('includes context, clusters, processes, schema, cluster detail, process detail', () => { + const templates = getResourceTemplates(); + const uris = templates.map(t => t.uriTemplate); + expect(uris).toContain('gitnexus://repo/{name}/context'); + expect(uris).toContain('gitnexus://repo/{name}/clusters'); + expect(uris).toContain('gitnexus://repo/{name}/processes'); + expect(uris).toContain('gitnexus://repo/{name}/schema'); + expect(uris).toContain('gitnexus://repo/{name}/cluster/{clusterName}'); + expect(uris).toContain('gitnexus://repo/{name}/process/{processName}'); + }); + + it('each template has uriTemplate, name, description, mimeType', () => { + for (const tmpl of getResourceTemplates()) { + expect(tmpl.uriTemplate).toBeTruthy(); + expect(tmpl.name).toBeTruthy(); + expect(tmpl.description).toBeTruthy(); + expect(tmpl.mimeType).toBeTruthy(); + } + }); +}); + +// ─── readResource URI parsing ──────────────────────────────────────── + +describe('readResource', () => { + it('routes gitnexus://repos to listRepos', async () => { + const backend = createMockBackend({ + repos: [ + { name: 'my-project', path: '/home/me/my-project', indexedAt: '2024-01-01', lastCommit: 'abc1234', stats: { files: 10, nodes: 50, processes: 5 } }, + ], + }); + + const result = await readResource('gitnexus://repos', backend); + expect(backend.listRepos).toHaveBeenCalled(); + expect(result).toContain('my-project'); + }); + + it('returns empty message when no repos', async () => { + const backend = createMockBackend({ repos: [] }); + const result = await readResource('gitnexus://repos', backend); + expect(result).toContain('No repositories indexed'); + }); + + it('routes gitnexus://setup to setup resource', async () => { + const backend = createMockBackend({ + repos: [ + { name: 'proj', path: '/tmp/proj', indexedAt: '2024-01-01', lastCommit: 'abc', stats: { nodes: 10, edges: 20, processes: 3 } }, + ], + }); + const result = await readResource('gitnexus://setup', backend); + expect(result).toContain('GitNexus MCP'); + expect(result).toContain('proj'); + }); + + it('returns fallback when setup has no repos', async () => { + const backend = createMockBackend({ repos: [] }); + const result = await readResource('gitnexus://setup', backend); + expect(result).toContain('No repositories indexed'); + }); + + it('routes gitnexus://repo/{name}/context correctly', async () => { + const backend = createMockBackend({ + context: { + projectName: 'test-project', + stats: { fileCount: 10, functionCount: 50, communityCount: 3, processCount: 5 }, + }, + }); + + const result = await readResource('gitnexus://repo/test-project/context', backend); + expect(backend.resolveRepo).toHaveBeenCalledWith('test-project'); + expect(result).toContain('test-project'); + expect(result).toContain('files: 10'); + }); + + it('returns error when context has no codebase loaded', async () => { + const backend = createMockBackend({ context: null }); + const result = await readResource('gitnexus://repo/test-project/context', backend); + expect(result).toContain('error'); + }); + + it('routes gitnexus://repo/{name}/schema to static schema', async () => { + const backend = createMockBackend(); + const result = await readResource('gitnexus://repo/any/schema', backend); + expect(result).toContain('GitNexus Graph Schema'); + expect(result).toContain('CALLS'); + expect(result).toContain('IMPORTS'); + }); + + it('routes gitnexus://repo/{name}/clusters correctly', async () => { + const backend = createMockBackend({ + clusters: { + clusters: [ + { heuristicLabel: 'Auth', symbolCount: 10, cohesion: 0.9 }, + ], + }, + }); + const result = await readResource('gitnexus://repo/test/clusters', backend); + expect(backend.queryClusters).toHaveBeenCalledWith('test', 100); + expect(result).toContain('Auth'); + }); + + it('returns empty modules when no clusters', async () => { + const backend = createMockBackend({ clusters: { clusters: [] } }); + const result = await readResource('gitnexus://repo/test/clusters', backend); + expect(result).toContain('modules: []'); + }); + + it('handles cluster query error gracefully', async () => { + const backend = createMockBackend(); + backend.queryClusters = vi.fn().mockRejectedValue(new Error('DB locked')); + const result = await readResource('gitnexus://repo/test/clusters', backend); + expect(result).toContain('DB locked'); + }); + + it('routes gitnexus://repo/{name}/processes correctly', async () => { + const backend = createMockBackend({ + processes: { + processes: [ + { heuristicLabel: 'LoginFlow', processType: 'intra_community', stepCount: 3 }, + ], + }, + }); + const result = await readResource('gitnexus://repo/test/processes', backend); + expect(backend.queryProcesses).toHaveBeenCalledWith('test', 50); + expect(result).toContain('LoginFlow'); + }); + + it('handles process query error gracefully', async () => { + const backend = createMockBackend(); + backend.queryProcesses = vi.fn().mockRejectedValue(new Error('timeout')); + const result = await readResource('gitnexus://repo/test/processes', backend); + expect(result).toContain('timeout'); + }); + + it('routes gitnexus://repo/{name}/cluster/{clusterName} correctly', async () => { + const backend = createMockBackend({ + clusterDetail: { + cluster: { heuristicLabel: 'Auth', symbolCount: 5, cohesion: 0.85 }, + members: [ + { name: 'login', type: 'Function', filePath: 'src/auth.ts' }, + ], + }, + }); + const result = await readResource('gitnexus://repo/test/cluster/Auth', backend); + expect(backend.queryClusterDetail).toHaveBeenCalledWith('Auth', 'test'); + expect(result).toContain('Auth'); + expect(result).toContain('login'); + }); + + it('handles cluster detail error', async () => { + const backend = createMockBackend({ + clusterDetail: { error: 'Cluster not found' }, + }); + const result = await readResource('gitnexus://repo/test/cluster/Missing', backend); + expect(result).toContain('Cluster not found'); + }); + + it('routes gitnexus://repo/{name}/process/{processName} correctly', async () => { + const backend = createMockBackend({ + processDetail: { + process: { heuristicLabel: 'LoginFlow', processType: 'intra_community', stepCount: 3 }, + steps: [ + { step: 1, name: 'login', filePath: 'src/auth.ts' }, + { step: 2, name: 'validate', filePath: 'src/validate.ts' }, + ], + }, + }); + const result = await readResource('gitnexus://repo/test/process/LoginFlow', backend); + expect(backend.queryProcessDetail).toHaveBeenCalledWith('LoginFlow', 'test'); + expect(result).toContain('LoginFlow'); + expect(result).toContain('login'); + expect(result).toContain('validate'); + }); + + it('handles process detail error', async () => { + const backend = createMockBackend({ + processDetail: { error: 'Process not found' }, + }); + const result = await readResource('gitnexus://repo/test/process/Missing', backend); + expect(result).toContain('Process not found'); + }); + + it('throws for unknown resource URI', async () => { + const backend = createMockBackend(); + await expect(readResource('gitnexus://unknown', backend)) + .rejects.toThrow('Unknown resource URI'); + }); + + it('throws for unknown repo-scoped resource type', async () => { + const backend = createMockBackend(); + await expect(readResource('gitnexus://repo/test/nonexistent', backend)) + .rejects.toThrow('Unknown resource'); + }); + + it('decodes URI-encoded repo names', async () => { + const backend = createMockBackend(); + await readResource('gitnexus://repo/my%20project/schema', backend); + // Should not throw — the schema resource is static + }); + + it('decodes URI-encoded cluster names', async () => { + const backend = createMockBackend({ + clusterDetail: { + cluster: { heuristicLabel: 'Auth Module', symbolCount: 5 }, + members: [], + }, + }); + await readResource('gitnexus://repo/test/cluster/Auth%20Module', backend); + expect(backend.queryClusterDetail).toHaveBeenCalledWith('Auth Module', 'test'); + }); + + it('repos resource shows multi-repo hint for multiple repos', async () => { + const backend = createMockBackend({ + repos: [ + { name: 'proj-a', path: '/a', indexedAt: '2024-01-01', lastCommit: 'abc' }, + { name: 'proj-b', path: '/b', indexedAt: '2024-01-02', lastCommit: 'def' }, + ], + }); + const result = await readResource('gitnexus://repos', backend); + expect(result).toContain('Multiple repos indexed'); + expect(result).toContain('repo parameter'); + }); +}); diff --git a/gitnexus/test/unit/schema.test.ts b/gitnexus/test/unit/schema.test.ts new file mode 100644 index 0000000000..87e369652f --- /dev/null +++ b/gitnexus/test/unit/schema.test.ts @@ -0,0 +1,185 @@ +import { describe, it, expect } from 'vitest'; +import { + NODE_TABLES, + REL_TABLE_NAME, + REL_TYPES, + EMBEDDING_TABLE_NAME, + NODE_SCHEMA_QUERIES, + REL_SCHEMA_QUERIES, + SCHEMA_QUERIES, + FILE_SCHEMA, + FOLDER_SCHEMA, + FUNCTION_SCHEMA, + CLASS_SCHEMA, + INTERFACE_SCHEMA, + METHOD_SCHEMA, + CODE_ELEMENT_SCHEMA, + COMMUNITY_SCHEMA, + PROCESS_SCHEMA, + RELATION_SCHEMA, + EMBEDDING_SCHEMA, + CREATE_VECTOR_INDEX_QUERY, +} from '../../src/core/lbug/schema.js'; + +describe('LadybugDB Schema', () => { + describe('NODE_TABLES', () => { + it('includes all core node types', () => { + const core = ['File', 'Folder', 'Function', 'Class', 'Interface', 'Method', 'CodeElement', 'Community', 'Process']; + for (const t of core) { + expect(NODE_TABLES).toContain(t); + } + }); + + it('includes multi-language node types', () => { + const multiLang = ['Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl', + 'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module']; + for (const t of multiLang) { + expect(NODE_TABLES).toContain(t); + } + }); + + it('has expected total count', () => { + // 9 core + 18 multi-language = 27 + expect(NODE_TABLES).toHaveLength(27); + }); + }); + + describe('REL_TYPES', () => { + it('includes all expected relationship types', () => { + const expected = ['CONTAINS', 'DEFINES', 'IMPORTS', 'CALLS', 'EXTENDS', 'IMPLEMENTS', 'MEMBER_OF', 'STEP_IN_PROCESS']; + for (const t of expected) { + expect(REL_TYPES).toContain(t); + } + }); + }); + + describe('node schema DDL', () => { + it.each([ + ['FILE_SCHEMA', FILE_SCHEMA, 'File'], + ['FOLDER_SCHEMA', FOLDER_SCHEMA, 'Folder'], + ['FUNCTION_SCHEMA', FUNCTION_SCHEMA, 'Function'], + ['CLASS_SCHEMA', CLASS_SCHEMA, 'Class'], + ['INTERFACE_SCHEMA', INTERFACE_SCHEMA, 'Interface'], + ['METHOD_SCHEMA', METHOD_SCHEMA, 'Method'], + ['CODE_ELEMENT_SCHEMA', CODE_ELEMENT_SCHEMA, 'CodeElement'], + ['COMMUNITY_SCHEMA', COMMUNITY_SCHEMA, 'Community'], + ['PROCESS_SCHEMA', PROCESS_SCHEMA, 'Process'], + ])('%s contains CREATE NODE TABLE for %s', (_, schema, tableName) => { + expect(schema).toContain('CREATE NODE TABLE'); + expect(schema).toContain(tableName); + expect(schema).toContain('PRIMARY KEY'); + }); + + it('Function schema has startLine and endLine', () => { + expect(FUNCTION_SCHEMA).toContain('startLine INT64'); + expect(FUNCTION_SCHEMA).toContain('endLine INT64'); + }); + + it('Function schema has isExported', () => { + expect(FUNCTION_SCHEMA).toContain('isExported BOOLEAN'); + }); + + it('Community schema has heuristicLabel and cohesion', () => { + expect(COMMUNITY_SCHEMA).toContain('heuristicLabel STRING'); + expect(COMMUNITY_SCHEMA).toContain('cohesion DOUBLE'); + }); + + it('Process schema has processType and stepCount', () => { + expect(PROCESS_SCHEMA).toContain('processType STRING'); + expect(PROCESS_SCHEMA).toContain('stepCount INT32'); + }); + }); + + describe('relation schema', () => { + it('creates a single REL TABLE named CodeRelation', () => { + expect(RELATION_SCHEMA).toContain(`CREATE REL TABLE ${REL_TABLE_NAME}`); + }); + + it('has type, confidence, reason, step properties', () => { + expect(RELATION_SCHEMA).toContain('type STRING'); + expect(RELATION_SCHEMA).toContain('confidence DOUBLE'); + expect(RELATION_SCHEMA).toContain('reason STRING'); + expect(RELATION_SCHEMA).toContain('step INT32'); + }); + + it('connects Function to Function (CALLS)', () => { + expect(RELATION_SCHEMA).toContain('FROM Function TO Function'); + }); + + it('connects File to Function (CONTAINS/DEFINES)', () => { + expect(RELATION_SCHEMA).toContain('FROM File TO Function'); + }); + + it('connects symbols to Community (MEMBER_OF)', () => { + expect(RELATION_SCHEMA).toContain('FROM Function TO Community'); + expect(RELATION_SCHEMA).toContain('FROM Class TO Community'); + }); + + it('connects symbols to Process (STEP_IN_PROCESS)', () => { + expect(RELATION_SCHEMA).toContain('FROM Function TO Process'); + expect(RELATION_SCHEMA).toContain('FROM Method TO Process'); + }); + + it('has all FROM/TO pairs needed for HAS_METHOD edges', () => { + // HAS_METHOD sources: Class, Interface, Struct, Trait, Impl, Record + // HAS_METHOD targets: Method, Constructor (Property is now HAS_PROPERTY) + const sources = ['Class', 'Interface']; + const backtickSources = ['Struct', 'Trait', 'Impl', 'Record']; + const targets = ['Method']; + const backtickTargets = ['Constructor']; + + // Non-backtick source → non-backtick target + for (const src of sources) { + for (const tgt of targets) { + expect(RELATION_SCHEMA).toContain(`FROM ${src} TO ${tgt}`); + } + for (const tgt of backtickTargets) { + expect(RELATION_SCHEMA).toContain(`FROM ${src} TO \`${tgt}\``); + } + } + + // Backtick source → all targets + for (const src of backtickSources) { + for (const tgt of targets) { + expect(RELATION_SCHEMA).toContain(`FROM \`${src}\` TO ${tgt}`); + } + for (const tgt of backtickTargets) { + expect(RELATION_SCHEMA).toContain(`FROM \`${src}\` TO \`${tgt}\``); + } + } + }); + }); + + describe('embedding schema', () => { + it('creates CodeEmbedding table', () => { + expect(EMBEDDING_SCHEMA).toContain(`CREATE NODE TABLE ${EMBEDDING_TABLE_NAME}`); + expect(EMBEDDING_SCHEMA).toContain('embedding FLOAT[384]'); + }); + + it('has vector index query', () => { + expect(CREATE_VECTOR_INDEX_QUERY).toContain('CREATE_VECTOR_INDEX'); + expect(CREATE_VECTOR_INDEX_QUERY).toContain('cosine'); + }); + }); + + describe('schema query ordering', () => { + it('NODE_SCHEMA_QUERIES has correct count', () => { + expect(NODE_SCHEMA_QUERIES).toHaveLength(27); + }); + + it('REL_SCHEMA_QUERIES has one relation table', () => { + expect(REL_SCHEMA_QUERIES).toHaveLength(1); + }); + + it('SCHEMA_QUERIES includes all node + rel + embedding schemas', () => { + // 27 node + 1 rel + 1 embedding = 29 + expect(SCHEMA_QUERIES).toHaveLength(29); + }); + + it('node schemas come before relation schemas in SCHEMA_QUERIES', () => { + const relIndex = SCHEMA_QUERIES.indexOf(RELATION_SCHEMA); + const lastNodeIndex = SCHEMA_QUERIES.indexOf(NODE_SCHEMA_QUERIES[NODE_SCHEMA_QUERIES.length - 1]); + expect(relIndex).toBeGreaterThan(lastNodeIndex); + }); + }); +}); diff --git a/gitnexus/test/unit/security.test.ts b/gitnexus/test/unit/security.test.ts new file mode 100644 index 0000000000..7464aa9f55 --- /dev/null +++ b/gitnexus/test/unit/security.test.ts @@ -0,0 +1,193 @@ +/** + * P0 Unit Tests: Security Hardening + * + * Tests all security hardening in isolation: + * - Write blocking (CYPHER_WRITE_RE) + * - Relation type allowlist + * - Path traversal detection + * - isWriteQuery wrapper + * - isTestFilePath patterns + */ +import { describe, it, expect } from 'vitest'; +import { + VALID_RELATION_TYPES, + VALID_NODE_LABELS, + isTestFilePath, +} from '../../src/mcp/local/local-backend.js'; +import { CYPHER_WRITE_RE, isWriteQuery } from '../../src/mcp/core/lbug-adapter.js'; + +// ─── Write-operation blocking (CYPHER_WRITE_RE) ────────────────────── + +describe('CYPHER_WRITE_RE', () => { + const writeKeywords = ['CREATE', 'DELETE', 'SET', 'MERGE', 'REMOVE', 'DROP', 'ALTER', 'COPY', 'DETACH']; + + for (const keyword of writeKeywords) { + it(`matches "${keyword}" (uppercase)`, () => { + expect(CYPHER_WRITE_RE.test(`${keyword} (n:Node)`)).toBe(true); + }); + + it(`matches "${keyword.toLowerCase()}" (lowercase)`, () => { + expect(CYPHER_WRITE_RE.test(`${keyword.toLowerCase()} (n:Node)`)).toBe(true); + }); + + it(`matches "${keyword[0] + keyword.slice(1).toLowerCase()}" (mixed case)`, () => { + const mixed = keyword[0] + keyword.slice(1).toLowerCase(); + expect(CYPHER_WRITE_RE.test(`${mixed} (n:Node)`)).toBe(true); + }); + } + + // Safe read queries should NOT be blocked + const safeQueries = [ + 'MATCH (n) RETURN n', + 'MATCH (n:Function) WHERE n.name = "foo" RETURN n', + 'MATCH (a)-[r]->(b) RETURN a, r, b', + 'OPTIONAL MATCH (n)-[r]->(m) RETURN n, r, m', + 'MATCH (n) WITH n RETURN n.name', + 'UNWIND [1,2,3] AS x RETURN x', + 'MATCH (n) RETURN count(n)', + 'MATCH (n:Function) WHERE n.filePath CONTAINS "test" RETURN n', + ]; + + for (const query of safeQueries) { + it(`does NOT block safe query: "${query.slice(0, 50)}..."`, () => { + expect(CYPHER_WRITE_RE.test(query)).toBe(false); + }); + } + + it('blocks write keyword within a longer query', () => { + expect(CYPHER_WRITE_RE.test('MATCH (n) DELETE n')).toBe(true); + expect(CYPHER_WRITE_RE.test('MATCH (n:Node) SET n.name = "x"')).toBe(true); + }); + + it('does not match partial word (e.g., "CREATED" should not match)', () => { + // \b ensures word boundary. "CREATED" starts with "CREATE" but has extra D + // Actually \b(CREATE) matches "CREATE" in "CREATED" since CREATE is followed by D + // which is a word char -> no boundary at E-D. Let's verify: + expect(CYPHER_WRITE_RE.test('CREATED_AT')).toBe(false); + }); +}); + +// ─── isWriteQuery wrapper ───────────────────────────────────────────── + +describe('isWriteQuery', () => { + it('returns true for write queries', () => { + expect(isWriteQuery('CREATE (n:Node)')).toBe(true); + expect(isWriteQuery('match (n) delete n')).toBe(true); + }); + + it('returns false for read queries', () => { + expect(isWriteQuery('MATCH (n) RETURN n')).toBe(false); + }); + + it('handles empty string', () => { + expect(isWriteQuery('')).toBe(false); + }); + + // Hardening: regex lastIndex not stuck (non-global regex, but verify) + it('works correctly on consecutive calls', () => { + expect(isWriteQuery('CREATE (n)')).toBe(true); + expect(isWriteQuery('MATCH (n) RETURN n')).toBe(false); + expect(isWriteQuery('DROP TABLE foo')).toBe(true); + expect(isWriteQuery('MATCH (n) RETURN n')).toBe(false); + }); +}); + +// ─── Relation type allowlist ────────────────────────────────────────── + +describe('VALID_RELATION_TYPES', () => { + it('contains exactly the expected 8 types', () => { + expect(VALID_RELATION_TYPES.size).toBe(8); + expect(VALID_RELATION_TYPES.has('CALLS')).toBe(true); + expect(VALID_RELATION_TYPES.has('IMPORTS')).toBe(true); + expect(VALID_RELATION_TYPES.has('EXTENDS')).toBe(true); + expect(VALID_RELATION_TYPES.has('IMPLEMENTS')).toBe(true); + expect(VALID_RELATION_TYPES.has('HAS_METHOD')).toBe(true); + expect(VALID_RELATION_TYPES.has('HAS_PROPERTY')).toBe(true); + expect(VALID_RELATION_TYPES.has('OVERRIDES')).toBe(true); + expect(VALID_RELATION_TYPES.has('ACCESSES')).toBe(true); + }); + + it('rejects invalid relation types', () => { + expect(VALID_RELATION_TYPES.has('CONTAINS')).toBe(false); + expect(VALID_RELATION_TYPES.has('USES')).toBe(false); + expect(VALID_RELATION_TYPES.has('calls')).toBe(false); // case-sensitive + expect(VALID_RELATION_TYPES.has('DROP_TABLE')).toBe(false); + }); +}); + +// ─── Valid node labels ─────────────────────────────────────────────── + +describe('VALID_NODE_LABELS', () => { + it('contains core node types', () => { + for (const label of ['File', 'Folder', 'Function', 'Class', 'Interface', 'Method', 'CodeElement']) { + expect(VALID_NODE_LABELS.has(label)).toBe(true); + } + }); + + it('contains meta node types', () => { + for (const label of ['Community', 'Process']) { + expect(VALID_NODE_LABELS.has(label)).toBe(true); + } + }); + + it('contains multi-language node types', () => { + for (const label of ['Struct', 'Enum', 'Macro', 'Trait', 'Impl', 'Namespace']) { + expect(VALID_NODE_LABELS.has(label)).toBe(true); + } + }); + + it('rejects invalid labels', () => { + expect(VALID_NODE_LABELS.has('InvalidType')).toBe(false); + expect(VALID_NODE_LABELS.has('function')).toBe(false); // case-sensitive + }); +}); + +// ─── Path traversal detection ──────────────────────────────────────── + +describe('path traversal (isTestFilePath as proxy for path handling)', () => { + it('isTestFilePath matches .test. files', () => { + expect(isTestFilePath('src/foo.test.ts')).toBe(true); + expect(isTestFilePath('src/foo.spec.ts')).toBe(true); + }); + + it('isTestFilePath matches __tests__ directory', () => { + expect(isTestFilePath('src/__tests__/foo.ts')).toBe(true); + }); + + it('isTestFilePath matches /test/ directory', () => { + expect(isTestFilePath('src/test/foo.ts')).toBe(true); + }); + + it('isTestFilePath handles Windows backslash paths', () => { + expect(isTestFilePath('src\\test\\foo.ts')).toBe(true); + expect(isTestFilePath('src\\__tests__\\bar.ts')).toBe(true); + }); + + it('isTestFilePath is case-insensitive', () => { + expect(isTestFilePath('SRC/TEST/Foo.ts')).toBe(true); + expect(isTestFilePath('SRC/Foo.Test.ts')).toBe(true); + }); + + it('isTestFilePath matches Go test files', () => { + expect(isTestFilePath('pkg/handler_test.go')).toBe(true); + }); + + it('isTestFilePath matches Python test files', () => { + expect(isTestFilePath('tests/test_handler.py')).toBe(true); + expect(isTestFilePath('pkg/handler_test.py')).toBe(true); + }); + + it('isTestFilePath returns false for non-test files', () => { + expect(isTestFilePath('src/main.ts')).toBe(false); + expect(isTestFilePath('src/utils/helper.ts')).toBe(false); + }); +}); + +// ─── Static analysis: parameterized query patterns ──────────────────── + +describe('parameterized query patterns (static analysis)', () => { + it('CYPHER_WRITE_RE is not a global regex (no lastIndex issue)', () => { + // A global regex would have sticky lastIndex state + expect(CYPHER_WRITE_RE.global).toBe(false); + }); +}); diff --git a/gitnexus/test/unit/sequential-language-availability.test.ts b/gitnexus/test/unit/sequential-language-availability.test.ts new file mode 100644 index 0000000000..0ab01c3f07 --- /dev/null +++ b/gitnexus/test/unit/sequential-language-availability.test.ts @@ -0,0 +1,145 @@ +import { describe, expect, it, vi, beforeEach } from 'vitest'; + +vi.mock('../../src/core/tree-sitter/parser-loader.js', () => ({ + loadParser: vi.fn(async () => ({ + parse: vi.fn(), + getLanguage: vi.fn(), + })), + loadLanguage: vi.fn(async () => undefined), + isLanguageAvailable: vi.fn(() => true), +})); + +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import { createASTCache } from '../../src/core/ingestion/ast-cache.js'; +import { processImports } from '../../src/core/ingestion/import-processor.js'; +import { processCalls } from '../../src/core/ingestion/call-processor.js'; +import { processHeritage } from '../../src/core/ingestion/heritage-processor.js'; +import { createResolutionContext } from '../../src/core/ingestion/resolution-context.js'; +import * as parserLoader from '../../src/core/tree-sitter/parser-loader.js'; + + +describe('sequential native parser availability', () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + it('skips Swift files in processImports when the native parser is unavailable', async () => { + vi.mocked(parserLoader.isLanguageAvailable).mockReturnValue(false); + + await expect(processImports( + createKnowledgeGraph(), + [{ path: 'App.swift', content: 'import Foundation' }], + createASTCache(), + createResolutionContext(), + undefined, + '/tmp/repo', + ['App.swift'], + )).resolves.toBeUndefined(); + + expect(parserLoader.loadLanguage).not.toHaveBeenCalled(); + }); + + it('warns when processImports skips files in verbose mode', async () => { + const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined); + const previous = process.env.GITNEXUS_VERBOSE; + process.env.GITNEXUS_VERBOSE = '1'; + vi.mocked(parserLoader.isLanguageAvailable).mockReturnValue(false); + + await processImports( + createKnowledgeGraph(), + [{ path: 'App.swift', content: 'import Foundation' }], + createASTCache(), + createResolutionContext(), + undefined, + '/tmp/repo', + ['App.swift'], + ); + + expect(warnSpy).toHaveBeenCalledWith( + '[ingestion] Skipped 1 swift file(s) in import processing — swift parser not available.' + ); + + warnSpy.mockRestore(); + if (previous === undefined) { + delete process.env.GITNEXUS_VERBOSE; + } else { + process.env.GITNEXUS_VERBOSE = previous; + } + }); + + it('skips Swift files in processCalls when the native parser is unavailable', async () => { + vi.mocked(parserLoader.isLanguageAvailable).mockReturnValue(false); + + await expect(processCalls( + createKnowledgeGraph(), + [{ path: 'App.swift', content: 'func demo() {}' }], + createASTCache(), + createResolutionContext(), + )).resolves.toEqual([]); + + expect(parserLoader.loadLanguage).not.toHaveBeenCalled(); + }); + + it('warns when processCalls skips files in verbose mode', async () => { + const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined); + const previous = process.env.GITNEXUS_VERBOSE; + process.env.GITNEXUS_VERBOSE = '1'; + vi.mocked(parserLoader.isLanguageAvailable).mockReturnValue(false); + + await processCalls( + createKnowledgeGraph(), + [{ path: 'App.swift', content: 'func demo() {}' }], + createASTCache(), + createResolutionContext(), + ); + + expect(warnSpy).toHaveBeenCalledWith( + '[ingestion] Skipped 1 swift file(s) in call processing — swift parser not available.' + ); + + warnSpy.mockRestore(); + if (previous === undefined) { + delete process.env.GITNEXUS_VERBOSE; + } else { + process.env.GITNEXUS_VERBOSE = previous; + } + }); + + it('skips Swift files in processHeritage when the native parser is unavailable', async () => { + vi.mocked(parserLoader.isLanguageAvailable).mockReturnValue(false); + + await expect(processHeritage( + createKnowledgeGraph(), + [{ path: 'App.swift', content: 'class AppViewController: UIViewController {}' }], + createASTCache(), + createResolutionContext(), + )).resolves.toBeUndefined(); + + expect(parserLoader.loadLanguage).not.toHaveBeenCalled(); + }); + + it('warns when processHeritage skips files in verbose mode', async () => { + const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined); + const previous = process.env.GITNEXUS_VERBOSE; + process.env.GITNEXUS_VERBOSE = '1'; + vi.mocked(parserLoader.isLanguageAvailable).mockReturnValue(false); + + await processHeritage( + createKnowledgeGraph(), + [{ path: 'App.swift', content: 'class AppViewController: UIViewController {}' }], + createASTCache(), + createResolutionContext(), + ); + + expect(warnSpy).toHaveBeenCalledWith( + '[ingestion] Skipped 1 swift file(s) in heritage processing — swift parser not available.' + ); + + warnSpy.mockRestore(); + if (previous === undefined) { + delete process.env.GITNEXUS_VERBOSE; + } else { + process.env.GITNEXUS_VERBOSE = previous; + } + }); +}); diff --git a/gitnexus/test/unit/server.test.ts b/gitnexus/test/unit/server.test.ts new file mode 100644 index 0000000000..f196c82e02 --- /dev/null +++ b/gitnexus/test/unit/server.test.ts @@ -0,0 +1,100 @@ +/** + * Unit Tests: MCP Server + * + * Tests: createMCPServer from server.ts + * - Server creation returns a Server instance + * - Tool handler wraps backend.callTool and appends hints + * - Tool handler catches errors and returns isError: true + * - Resource handlers delegate to resources.ts functions + * - Prompt handlers return expected prompts + * - Next-step hints cover all tool names + * + * NOTE: We test the server handler logic by calling the request handlers + * directly through the MCP Server's handler dispatch. + */ +import { describe, it, expect, vi, beforeAll } from 'vitest'; +import { createMCPServer } from '../../src/mcp/server.js'; + +// ─── Mock backend ────────────────────────────────────────────────── + +function createMockBackend(overrides: Record<string, any> = {}): any { + return { + callTool: vi.fn().mockResolvedValue({ result: 'ok' }), + listRepos: vi.fn().mockResolvedValue([]), + resolveRepo: vi.fn().mockResolvedValue({ name: 'test', repoPath: '/tmp/test', lastCommit: 'abc' }), + getContext: vi.fn().mockReturnValue(null), + queryClusters: vi.fn().mockResolvedValue({ clusters: [] }), + queryProcesses: vi.fn().mockResolvedValue({ processes: [] }), + queryClusterDetail: vi.fn().mockResolvedValue({ error: 'not found' }), + queryProcessDetail: vi.fn().mockResolvedValue({ error: 'not found' }), + disconnect: vi.fn().mockResolvedValue(undefined), + ...overrides, + }; +} + +// ─── createMCPServer ───────────────────────────────────────────────── + +describe('createMCPServer', () => { + it('returns a Server instance with expected shape', () => { + const backend = createMockBackend(); + const server = createMCPServer(backend); + expect(server).toBeDefined(); + // Server should have connect/close methods + expect(typeof server.connect).toBe('function'); + expect(typeof server.close).toBe('function'); + }); + + it('server has setRequestHandler method', () => { + const backend = createMockBackend(); + const server = createMCPServer(backend); + // The server has registered handlers — verify it was created without errors + expect(server).toBeTruthy(); + }); +}); + +// ─── getNextStepHint (tested indirectly via server tool handler) ────── + +describe('getNextStepHint (via tool call response)', () => { + // We test hints by calling the server's tool handler indirectly. + // Since createMCPServer registers handlers on the Server, we verify + // hints are appended by checking the tool response format. + + it('query tool response includes hint about context', async () => { + const backend = createMockBackend({ + callTool: vi.fn().mockResolvedValue({ processes: [], definitions: [] }), + }); + const server = createMCPServer(backend); + + // We can't easily call handlers directly on the MCP Server, + // so we verify the handler was registered by creating the server without error. + // The actual hint logic is tested via the integration path. + expect(backend.callTool).not.toHaveBeenCalled(); // not called until request + }); +}); + +// ─── Tool handler error handling ────────────────────────────────────── + +describe('server error handling', () => { + it('createMCPServer does not throw for valid backend', () => { + const backend = createMockBackend(); + expect(() => createMCPServer(backend)).not.toThrow(); + }); + + it('createMCPServer reads version from package.json', () => { + const backend = createMockBackend(); + const server = createMCPServer(backend); + // Server was created with version from package.json — no crash + expect(server).toBeDefined(); + }); +}); + +// ─── Prompt definitions ─────────────────────────────────────────────── + +describe('prompt registration', () => { + it('server registers detect_impact and generate_map prompts', () => { + const backend = createMockBackend(); + // Creating the server registers all handlers including prompts + const server = createMCPServer(backend); + expect(server).toBeDefined(); + }); +}); diff --git a/gitnexus/test/unit/shared-type-extractors.test.ts b/gitnexus/test/unit/shared-type-extractors.test.ts new file mode 100644 index 0000000000..1d925feb5c --- /dev/null +++ b/gitnexus/test/unit/shared-type-extractors.test.ts @@ -0,0 +1,563 @@ +import { describe, it, expect } from 'vitest'; +import { + extractElementTypeFromString, + stripNullable, + extractReturnTypeName, + methodToTypeArgPosition, + getContainerDescriptor, +} from '../../src/core/ingestion/type-extractors/shared.js'; + +// --------------------------------------------------------------------------- +// extractElementTypeFromString +// --------------------------------------------------------------------------- + +describe('extractElementTypeFromString', () => { + // --- Array suffix --- + it('strips array suffix: User[] → User', () => { + expect(extractElementTypeFromString('User[]')).toBe('User'); + }); + + it('strips array suffix for primitive: string[] → string', () => { + expect(extractElementTypeFromString('string[]')).toBe('string'); + }); + + it('returns undefined for just brackets: []', () => { + // Empty base after stripping suffix + expect(extractElementTypeFromString('[]')).toBeUndefined(); + }); + + it('returns undefined when base is not a simple word: user model[]', () => { + expect(extractElementTypeFromString('user model[]')).toBeUndefined(); + }); + + // --- Go slice prefix --- + it('strips Go slice prefix: []User → User', () => { + expect(extractElementTypeFromString('[]User')).toBe('User'); + }); + + it('strips Go slice prefix for primitive: []string → string', () => { + expect(extractElementTypeFromString('[]string')).toBe('string'); + }); + + // --- Swift array sugar --- + it('unwraps Swift array sugar: [User] → User', () => { + expect(extractElementTypeFromString('[User]')).toBe('User'); + }); + + // --- Generic angle brackets --- + it('unwraps single-arg generic angle: Array<User> → User', () => { + expect(extractElementTypeFromString('Array<User>')).toBe('User'); + }); + + it('unwraps single-arg generic angle: C++ vector<User> → User', () => { + expect(extractElementTypeFromString('vector<User>')).toBe('User'); + }); + + it('unwraps single-arg generic angle: Rust Vec<User> → User', () => { + expect(extractElementTypeFromString('Vec<User>')).toBe('User'); + }); + + // --- Generic square brackets --- + it('unwraps Python subscript: List[User] → User', () => { + expect(extractElementTypeFromString('List[User]')).toBe('User'); + }); + + // --- Multi-argument generics --- + it('returns last arg by default for Map<String, User>: → User', () => { + expect(extractElementTypeFromString('Map<String, User>')).toBe('User'); + }); + + it('returns first arg with pos=first for Map<String, User>: → String', () => { + expect(extractElementTypeFromString('Map<String, User>', 'first')).toBe('String'); + }); + + it('returns last arg explicitly for Map<String, User>: → User', () => { + expect(extractElementTypeFromString('Map<String, User>', 'last')).toBe('User'); + }); + + // --- Nested generics --- + it('returns undefined for nested generics: List<Map<String, User>>', () => { + // The inner arg "Map<String, User>" is not a simple word (/^\w+$/ fails) + expect(extractElementTypeFromString('List<Map<String, User>>')).toBeUndefined(); + }); + + // --- Guard conditions --- + it('returns undefined for empty string', () => { + expect(extractElementTypeFromString('')).toBeUndefined(); + }); + + it('returns undefined for string longer than 2048 chars', () => { + expect(extractElementTypeFromString('A'.repeat(2049))).toBeUndefined(); + }); + + it('returns undefined at exactly the 2048-char limit', () => { + // Length > 2048 is rejected; length === 2048 may or may not parse — test boundary + const exactly2048 = 'A'.repeat(2048); + // This won't contain valid container syntax, so it won't resolve, but it won't be + // rejected by the length guard alone. We only assert > 2048 is rejected. + expect(extractElementTypeFromString('A'.repeat(2049))).toBeUndefined(); + }); + + it('returns undefined for malformed brackets: Map<String, User]', () => { + // Mismatched bracket at depth 0 → malformed + expect(extractElementTypeFromString('Map<String, User]')).toBeUndefined(); + }); + + it('returns undefined for just closing angle brackets: >', () => { + expect(extractElementTypeFromString('>')).toBeUndefined(); + }); + + it('returns undefined when no brackets are present: User', () => { + // No opening bracket → falls through to undefined + expect(extractElementTypeFromString('User')).toBeUndefined(); + }); + + it('returns undefined for complex non-word base before []: user model[]', () => { + expect(extractElementTypeFromString('user model[]')).toBeUndefined(); + }); + + // --- Edge cases for Swift vs List-subscript disambiguation --- + it('does not treat [User] as Swift if it contains angle bracket (impossible case sanity-check)', () => { + // [User<X>] — starts with [ ends with ] but contains <, so Swift path is skipped. + // Falls to generic extraction: openSquare=0, extracts "User<X>" which is not /^\w+$/. + expect(extractElementTypeFromString('[User<X>]')).toBeUndefined(); + }); + + // --- pos='first' on single-arg container falls through to the same result --- + it('returns same result for Vec<User> with pos=first', () => { + expect(extractElementTypeFromString('Vec<User>', 'first')).toBe('User'); + }); + + // --- Whitespace inside generics --- + it('handles whitespace in generic args: Array< User > → User', () => { + expect(extractElementTypeFromString('Array< User >')).toBe('User'); + }); +}); + +// --------------------------------------------------------------------------- +// stripNullable +// --------------------------------------------------------------------------- + +describe('stripNullable', () => { + // --- Nullable union stripping --- + it('strips "| null": User | null → User', () => { + expect(stripNullable('User | null')).toBe('User'); + }); + + it('strips "| undefined": User | undefined → User', () => { + expect(stripNullable('User | undefined')).toBe('User'); + }); + + it('strips both "| null | undefined": User | null | undefined → User', () => { + expect(stripNullable('User | null | undefined')).toBe('User'); + }); + + // --- Nullable suffix --- + it('strips nullable suffix: User? → User', () => { + expect(stripNullable('User?')).toBe('User'); + }); + + // --- Genuine union is rejected --- + it('returns undefined for genuine union: User | Repo', () => { + expect(stripNullable('User | Repo')).toBeUndefined(); + }); + + // --- Bare nullable keywords --- + it('returns undefined for bare "null"', () => { + expect(stripNullable('null')).toBeUndefined(); + }); + + it('returns undefined for bare "undefined"', () => { + expect(stripNullable('undefined')).toBeUndefined(); + }); + + it('returns undefined for bare "None"', () => { + expect(stripNullable('None')).toBeUndefined(); + }); + + it('returns undefined for bare "nil"', () => { + expect(stripNullable('nil')).toBeUndefined(); + }); + + it('returns undefined for bare "void"', () => { + expect(stripNullable('void')).toBeUndefined(); + }); + + // --- Empty / whitespace --- + it('returns undefined for empty string', () => { + expect(stripNullable('')).toBeUndefined(); + }); + + it('returns undefined for whitespace-only string', () => { + expect(stripNullable(' ')).toBeUndefined(); + }); + + // --- Trimming --- + it('trims surrounding whitespace: " User " → User', () => { + expect(stripNullable(' User ')).toBe('User'); + }); + + // --- No-op for clean type names --- + it('returns the type name unchanged when no nullable markers: User → User', () => { + expect(stripNullable('User')).toBe('User'); + }); + + // --- All-nullable union is rejected --- + it('returns undefined when the union is all nullable keywords: null | undefined', () => { + expect(stripNullable('null | undefined')).toBeUndefined(); + }); + + // --- Nullable suffix does NOT interact with pipe (order matters) --- + it('returns "User?" when ? is embedded before pipe: User? | null', () => { + // The ? strip only fires when the whole string ends with '?'. + // "User? | null" ends with 'null', so ? is NOT stripped first. + // The pipe branch splits → parts: ['User?', 'null'] → filters 'null' → one part + // remaining is 'User?' (not in NULLABLE_KEYWORDS), so it is returned as-is. + expect(stripNullable('User? | null')).toBe('User?'); + }); +}); + +// --------------------------------------------------------------------------- +// extractReturnTypeName +// --------------------------------------------------------------------------- + +describe('extractReturnTypeName', () => { + // --- Simple user-defined type --- + it('returns simple type: User → User', () => { + expect(extractReturnTypeName('User')).toBe('User'); + }); + + // --- Wrapper generics unwrapping --- + it('unwraps Promise: Promise<User> → User', () => { + expect(extractReturnTypeName('Promise<User>')).toBe('User'); + }); + + it('unwraps Option: Option<User> → User', () => { + expect(extractReturnTypeName('Option<User>')).toBe('User'); + }); + + it('unwraps Result (first arg): Result<User, Error> → User', () => { + expect(extractReturnTypeName('Result<User, Error>')).toBe('User'); + }); + + // --- Nullable union / suffix --- + it('strips nullable union: User | null → User', () => { + expect(extractReturnTypeName('User | null')).toBe('User'); + }); + + it('strips nullable suffix: User? → User', () => { + expect(extractReturnTypeName('User?')).toBe('User'); + }); + + // --- Pointer / reference prefix stripping --- + it('strips Go pointer prefix: *User → User', () => { + expect(extractReturnTypeName('*User')).toBe('User'); + }); + + it('strips Rust reference prefix: &User → User', () => { + expect(extractReturnTypeName('&User')).toBe('User'); + }); + + it('strips Rust mutable reference prefix: &mut User → User', () => { + expect(extractReturnTypeName('&mut User')).toBe('User'); + }); + + // --- Non-wrapper generic returns base type --- + it('returns base type for non-wrapper generic: List<User> → List', () => { + expect(extractReturnTypeName('List<User>')).toBe('List'); + }); + + // --- Qualified names --- + it('extracts last segment of dot-qualified name: models.User → User', () => { + expect(extractReturnTypeName('models.User')).toBe('User'); + }); + + it('extracts last segment of PHP namespace: \\App\\Models\\User → User', () => { + expect(extractReturnTypeName('\\App\\Models\\User')).toBe('User'); + }); + + it('extracts last segment of Rust path: models::User → User', () => { + expect(extractReturnTypeName('models::User')).toBe('User'); + }); + + // --- Primitives rejected --- + it('returns undefined for primitive "string"', () => { + expect(extractReturnTypeName('string')).toBeUndefined(); + }); + + it('returns undefined for primitive "int"', () => { + expect(extractReturnTypeName('int')).toBeUndefined(); + }); + + it('returns undefined for primitive "boolean"', () => { + expect(extractReturnTypeName('boolean')).toBeUndefined(); + }); + + it('returns undefined for primitive "void"', () => { + expect(extractReturnTypeName('void')).toBeUndefined(); + }); + + // --- Lowercase (non-uppercase start) rejected --- + it('returns undefined for lowercase identifier: user', () => { + expect(extractReturnTypeName('user')).toBeUndefined(); + }); + + // --- Empty --- + it('returns undefined for empty string', () => { + expect(extractReturnTypeName('')).toBeUndefined(); + }); + + // --- Bare wrapper without type arg --- + it('returns undefined for bare wrapper without type arg: Promise', () => { + expect(extractReturnTypeName('Promise')).toBeUndefined(); + }); + + it('returns undefined for bare wrapper: Option', () => { + expect(extractReturnTypeName('Option')).toBeUndefined(); + }); + + // --- Recursive unwrap (nested wrappers) --- + it('recursively unwraps nested wrappers: Future<Option<User>> → User', () => { + expect(extractReturnTypeName('Future<Option<User>>')).toBe('User'); + }); + + // --- Rust smart pointer --- + it('unwraps Rc: Rc<User> → User', () => { + expect(extractReturnTypeName('Rc<User>')).toBe('User'); + }); + + it('unwraps Arc: Arc<User> → User', () => { + expect(extractReturnTypeName('Arc<User>')).toBe('User'); + }); + + // --- Guard conditions --- + it('returns undefined for input longer than 2048 chars', () => { + expect(extractReturnTypeName('A'.repeat(2049))).toBeUndefined(); + }); + + it('returns undefined when depth > 10', () => { + expect(extractReturnTypeName('User', 11)).toBeUndefined(); + }); + + // --- Rust lifetimes in Result --- + it('skips Rust lifetime parameters in Result: Result<\'_, User, Error> is unusual but lifetime in first pos is skipped', () => { + // Lifetime as FIRST arg: Result<'a, User> — extractFirstTypeArg skips lifetimes + expect(extractReturnTypeName("Result<'a, User>")).toBe('User'); + }); + + it('skips Rust anonymous lifetime: Result<\'_, User>', () => { + expect(extractReturnTypeName("Result<'_, User>")).toBe('User'); + }); + + // --- Genuine union is rejected --- + it('returns undefined for genuine union: User | Repo', () => { + expect(extractReturnTypeName('User | Repo')).toBeUndefined(); + }); + + // --- Uppercase-start constraint --- + it('accepts underscore-start identifier: _User', () => { + // Pattern is /^[A-Z_]\w*$/ — underscore start is accepted + expect(extractReturnTypeName('_User')).toBe('_User'); + }); + + // --- Type with multiple pointer sigils --- + it('strips multiple pointer sigils: **User → User', () => { + // Regex: /^[&*]+\s*(mut\s+)?/ strips all leading & and * + expect(extractReturnTypeName('**User')).toBe('User'); + }); +}); + +// --------------------------------------------------------------------------- +// methodToTypeArgPosition +// --------------------------------------------------------------------------- + +describe('methodToTypeArgPosition', () => { + // --- Known single-element container → always 'last' --- + it('returns last for known single-element container method: get on Array', () => { + expect(methodToTypeArgPosition('get', 'Array')).toBe('last'); + }); + + it('returns last for iter on Vec (single-element)', () => { + expect(methodToTypeArgPosition('iter', 'Vec')).toBe('last'); + }); + + // --- Known map container with key method --- + it('returns first for keys on Map', () => { + expect(methodToTypeArgPosition('keys', 'Map')).toBe('first'); + }); + + it('returns last for values on Map', () => { + expect(methodToTypeArgPosition('values', 'Map')).toBe('last'); + }); + + it('returns last for get on Map (value method)', () => { + expect(methodToTypeArgPosition('get', 'Map')).toBe('last'); + }); + + // --- Java-specific keySet --- + it('returns first for keySet on LinkedHashMap (Java keyMethods)', () => { + expect(methodToTypeArgPosition('keySet', 'LinkedHashMap')).toBe('first'); + }); + + it('returns first for keySet on HashMap (Java keyMethods via STD_KEY_METHODS — note: HashMap uses STD_KEY_METHODS, not JAVA_KEY_METHODS)', () => { + // HashMap uses STD_KEY_METHODS which has 'keys', not 'keySet' + // So keySet on HashMap is not a key method → falls to 'last' + expect(methodToTypeArgPosition('keySet', 'HashMap')).toBe('last'); + }); + + it('returns first for keySet on TreeMap (JAVA_KEY_METHODS)', () => { + expect(methodToTypeArgPosition('keySet', 'TreeMap')).toBe('first'); + }); + + // --- C# Keys property --- + it('returns first for Keys on Dictionary (C# key method)', () => { + expect(methodToTypeArgPosition('Keys', 'Dictionary')).toBe('first'); + }); + + it('returns last for Values on Dictionary (C# value method)', () => { + expect(methodToTypeArgPosition('Values', 'Dictionary')).toBe('last'); + }); + + // --- Unknown container falls back to method name heuristic --- + it('returns first for keys on unknown container: keys on MyMap', () => { + expect(methodToTypeArgPosition('keys', 'MyMap')).toBe('first'); + }); + + it('returns last for get on unknown container: get on MyMap', () => { + expect(methodToTypeArgPosition('get', 'MyMap')).toBe('last'); + }); + + it('returns first for keySet on unknown container (fallback heuristic)', () => { + expect(methodToTypeArgPosition('keySet', 'MyMap')).toBe('first'); + }); + + it('returns first for Keys on unknown container (fallback heuristic)', () => { + expect(methodToTypeArgPosition('Keys', 'SomeUnknownMap')).toBe('first'); + }); + + // --- Undefined method / no container --- + it('returns last when method and container are both undefined', () => { + expect(methodToTypeArgPosition(undefined)).toBe('last'); + }); + + it('returns last when method is undefined and container is known map', () => { + // containerTypeName is Map (arity 2), method is undefined → not in keyMethods → 'last' + expect(methodToTypeArgPosition(undefined, 'Map')).toBe('last'); + }); + + it('returns last for unknown method on unknown container', () => { + expect(methodToTypeArgPosition('somethingElse', 'FooBar')).toBe('last'); + }); + + // --- No container provided, non-key method --- + it('returns last for non-key method with no container', () => { + expect(methodToTypeArgPosition('get')).toBe('last'); + }); + + it('returns first for keys with no container', () => { + expect(methodToTypeArgPosition('keys')).toBe('first'); + }); +}); + +// --------------------------------------------------------------------------- +// getContainerDescriptor +// --------------------------------------------------------------------------- + +describe('getContainerDescriptor', () => { + // --- Known map-type (arity 2) --- + it('returns descriptor with arity 2 for Map', () => { + const desc = getContainerDescriptor('Map'); + expect(desc).toBeDefined(); + expect(desc!.arity).toBe(2); + }); + + it('descriptor for Map has keys in keyMethods', () => { + const desc = getContainerDescriptor('Map'); + expect(desc!.keyMethods.has('keys')).toBe(true); + }); + + it('descriptor for Map has get in valueMethods', () => { + const desc = getContainerDescriptor('Map'); + expect(desc!.valueMethods.has('get')).toBe(true); + }); + + it('returns descriptor with arity 2 for HashMap', () => { + const desc = getContainerDescriptor('HashMap'); + expect(desc).toBeDefined(); + expect(desc!.arity).toBe(2); + }); + + it('returns descriptor with arity 2 for Dictionary (C#)', () => { + const desc = getContainerDescriptor('Dictionary'); + expect(desc).toBeDefined(); + expect(desc!.arity).toBe(2); + }); + + // --- Known single-element container (arity 1) --- + it('returns descriptor with arity 1 for Vec', () => { + const desc = getContainerDescriptor('Vec'); + expect(desc).toBeDefined(); + expect(desc!.arity).toBe(1); + }); + + it('descriptor for Vec has empty keyMethods', () => { + const desc = getContainerDescriptor('Vec'); + expect(desc!.keyMethods.size).toBe(0); + }); + + it('descriptor for Vec has get in valueMethods', () => { + const desc = getContainerDescriptor('Vec'); + expect(desc!.valueMethods.has('get')).toBe(true); + }); + + it('returns descriptor with arity 1 for Array', () => { + const desc = getContainerDescriptor('Array'); + expect(desc).toBeDefined(); + expect(desc!.arity).toBe(1); + }); + + it('returns descriptor with arity 1 for List', () => { + const desc = getContainerDescriptor('List'); + expect(desc).toBeDefined(); + expect(desc!.arity).toBe(1); + }); + + // --- Unknown type --- + it('returns undefined for unknown type: FooBar', () => { + expect(getContainerDescriptor('FooBar')).toBeUndefined(); + }); + + it('returns undefined for empty string', () => { + expect(getContainerDescriptor('')).toBeUndefined(); + }); + + it('returns undefined for lowercase unknown: mycontainer', () => { + expect(getContainerDescriptor('mycontainer')).toBeUndefined(); + }); + + // --- Lowercase built-in containers --- + it('returns descriptor for lowercase list (Python)', () => { + const desc = getContainerDescriptor('list'); + expect(desc).toBeDefined(); + expect(desc!.arity).toBe(1); + }); + + it('returns descriptor for lowercase dict (Python)', () => { + const desc = getContainerDescriptor('dict'); + expect(desc).toBeDefined(); + expect(desc!.arity).toBe(2); + }); + + // --- Java-specific map with keySet --- + it('descriptor for TreeMap has keySet in keyMethods', () => { + const desc = getContainerDescriptor('TreeMap'); + expect(desc).toBeDefined(); + expect(desc!.keyMethods.has('keySet')).toBe(true); + }); + + it('descriptor for ConcurrentHashMap has keySet in keyMethods', () => { + const desc = getContainerDescriptor('ConcurrentHashMap'); + expect(desc).toBeDefined(); + expect(desc!.keyMethods.has('keySet')).toBe(true); + }); +}); diff --git a/gitnexus/test/unit/skill-gen.test.ts b/gitnexus/test/unit/skill-gen.test.ts new file mode 100644 index 0000000000..3a9d127e2a --- /dev/null +++ b/gitnexus/test/unit/skill-gen.test.ts @@ -0,0 +1,712 @@ +/** + * Unit & integration tests for the skill file generator. + * + * Tests generateSkillFiles() — the only public export from cli/skill-gen.ts. + * Validates return values (skill metadata), aggregation logic, edge cases, + * and the on-disk SKILL.md files produced. + */ +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; +import fs from 'fs/promises'; +import path from 'path'; +import os from 'os'; +import { generateSkillFiles } from '../../src/cli/skill-gen.js'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; +import type { GraphNode, GraphRelationship, KnowledgeGraph } from '../../src/core/graph/types.js'; +import type { CommunityNode, CommunityMembership, CommunityDetectionResult } from '../../src/core/ingestion/community-processor.js'; +import type { ProcessNode, ProcessDetectionResult } from '../../src/core/ingestion/process-processor.js'; +import type { PipelineResult } from '../../src/types/pipeline.js'; + +// ============================================================================ +// FIXTURE HELPERS +// ============================================================================ + +/** Create a GraphNode with commonly-needed properties */ +function makeNode( + id: string, + name: string, + label: GraphNode['label'], + filePath: string, + startLine: number, + isExported: boolean, +): GraphNode { + return { + id, + label, + properties: { name, filePath, startLine, endLine: startLine + 10, isExported }, + }; +} + +/** Create a GraphRelationship between two nodes */ +function makeRel( + id: string, + sourceId: string, + targetId: string, + type: GraphRelationship['type'], +): GraphRelationship { + return { id, sourceId, targetId, type, confidence: 1.0, reason: '' }; +} + +/** Create a CommunityNode with default cohesion */ +function makeCommunity( + id: string, + label: string, + symbolCount: number, + cohesion: number = 0.75, +): CommunityNode { + return { id, label, heuristicLabel: label, cohesion, symbolCount }; +} + +/** Create a membership record linking a node to a community */ +function makeMembership(nodeId: string, communityId: string): CommunityMembership { + return { nodeId, communityId }; +} + +/** Create a ProcessNode for testing execution flows */ +function makeProcess( + id: string, + label: string, + communities: string[], + stepCount: number, +): ProcessNode { + return { + id, + label, + heuristicLabel: label, + processType: communities.length > 1 ? 'cross_community' : 'intra_community', + stepCount, + communities, + entryPointId: '', + terminalId: '', + trace: [], + }; +} + +/** + * Assemble a full PipelineResult from individual pieces. + * Only graph is required; community and process data default to empty. + */ +function buildPipelineResult(opts: { + graph: KnowledgeGraph; + repoPath: string; + communities?: CommunityNode[]; + memberships?: CommunityMembership[]; + processes?: ProcessNode[]; +}): PipelineResult { + const communityResult: CommunityDetectionResult = { + communities: opts.communities ?? [], + memberships: opts.memberships ?? [], + stats: { + totalCommunities: (opts.communities ?? []).length, + modularity: 0.5, + nodesProcessed: (opts.memberships ?? []).length, + }, + }; + + const processResult: ProcessDetectionResult | undefined = + opts.processes + ? { + processes: opts.processes, + steps: [], + stats: { + totalProcesses: opts.processes.length, + crossCommunityCount: opts.processes.filter(p => p.processType === 'cross_community').length, + avgStepCount: opts.processes.length > 0 + ? opts.processes.reduce((s, p) => s + p.stepCount, 0) / opts.processes.length + : 0, + entryPointsFound: 0, + }, + } + : undefined; + + return { + graph: opts.graph, + repoPath: opts.repoPath, + totalFileCount: 0, + communityResult, + processResult, + }; +} + +// ============================================================================ +// TESTS — RETURN VALUES +// ============================================================================ + +describe('generateSkillFiles — return values', () => { + let tmpDir: string; + + beforeEach(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-skill-test-')); + vi.spyOn(console, 'log').mockImplementation(() => {}); + }); + + afterEach(async () => { + vi.restoreAllMocks(); + try { + await fs.rm(tmpDir, { recursive: true, force: true }); + } catch { /* best-effort */ } + }); + + /** + * When memberships array is empty, there is nothing to group into skills. + * Should return an empty skills array and the expected output path. + */ + it('returns empty skills when memberships is empty', async () => { + const graph = createKnowledgeGraph(); + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, + repoPath: tmpDir, + communities: [], + memberships: [], + })); + + expect(result.skills).toEqual([]); + expect(result.outputPath).toBe(path.join(tmpDir, '.claude', 'skills', 'generated')); + }); + + /** + * Communities with fewer than 3 symbols are filtered out. + * Three communities each with 2 symbols should all be excluded. + */ + it('returns empty skills when all communities are below threshold', async () => { + const graph = createKnowledgeGraph(); + // Add 6 nodes — 2 per community + for (let i = 0; i < 6; i++) { + graph.addNode(makeNode(`fn:n${i}`, `n${i}`, 'Function', `${tmpDir}/src/f${i}.ts`, 1, false)); + } + + const communities = [ + makeCommunity('c1', 'Small1', 2), + makeCommunity('c2', 'Small2', 2), + makeCommunity('c3', 'Small3', 2), + ]; + const memberships = [ + makeMembership('fn:n0', 'c1'), makeMembership('fn:n1', 'c1'), + makeMembership('fn:n2', 'c2'), makeMembership('fn:n3', 'c2'), + makeMembership('fn:n4', 'c3'), makeMembership('fn:n5', 'c3'), + ]; + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toEqual([]); + }); + + /** + * A single valid community with 5 nodes across 2 files, some exported. + * Should return exactly 1 skill with correct metadata. + */ + it('returns 1 skill for a single valid community', async () => { + const graph = createKnowledgeGraph(); + graph.addNode(makeNode('fn:a', 'alpha', 'Function', `${tmpDir}/src/auth/login.ts`, 1, true)); + graph.addNode(makeNode('fn:b', 'beta', 'Function', `${tmpDir}/src/auth/login.ts`, 20, false)); + graph.addNode(makeNode('fn:c', 'gamma', 'Class', `${tmpDir}/src/auth/session.ts`, 1, true)); + graph.addNode(makeNode('fn:d', 'delta', 'Function', `${tmpDir}/src/auth/session.ts`, 40, false)); + graph.addNode(makeNode('fn:e', 'epsilon', 'Function', `${tmpDir}/src/auth/session.ts`, 60, true)); + + const communities = [makeCommunity('c1', 'Auth', 5, 0.8)]; + const memberships = ['fn:a', 'fn:b', 'fn:c', 'fn:d', 'fn:e'] + .map(id => makeMembership(id, 'c1')); + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toHaveLength(1); + expect(result.skills[0].label).toBe('Auth'); + expect(result.skills[0].symbolCount).toBe(5); + expect(result.skills[0].fileCount).toBe(2); + expect(result.skills[0].name).toBe('auth'); + }); + + /** + * Two communities with the same heuristicLabel should be aggregated + * into one skill with summed symbolCount. + */ + it('aggregates communities with same label into one skill', async () => { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 8; i++) { + graph.addNode(makeNode(`fn:n${i}`, `n${i}`, 'Function', `${tmpDir}/src/auth/f${i}.ts`, 1, false)); + } + + const communities = [ + makeCommunity('c1', 'Auth', 4, 0.7), + makeCommunity('c2', 'Auth', 4, 0.9), + ]; + const memberships = [ + ...['fn:n0', 'fn:n1', 'fn:n2', 'fn:n3'].map(id => makeMembership(id, 'c1')), + ...['fn:n4', 'fn:n5', 'fn:n6', 'fn:n7'].map(id => makeMembership(id, 'c2')), + ]; + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toHaveLength(1); + expect(result.skills[0].label).toBe('Auth'); + expect(result.skills[0].symbolCount).toBe(8); + }); + + /** + * The generator caps output at 20 skills regardless of how many + * communities pass the threshold. + */ + it('caps skills at 20 even with more valid communities', async () => { + const graph = createKnowledgeGraph(); + const communities: CommunityNode[] = []; + const memberships: CommunityMembership[] = []; + + for (let i = 0; i < 25; i++) { + const commId = `c${i}`; + communities.push(makeCommunity(commId, `Area${i}`, 4)); + for (let j = 0; j < 4; j++) { + const nodeId = `fn:c${i}_n${j}`; + graph.addNode(makeNode(nodeId, `func_${i}_${j}`, 'Function', `${tmpDir}/src/area${i}/f${j}.ts`, 1, false)); + memberships.push(makeMembership(nodeId, commId)); + } + } + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toHaveLength(20); + }); + + /** + * Skills should be sorted by symbolCount descending so the most + * significant community appears first. + */ + it('sorts skills by symbol count descending', async () => { + const graph = createKnowledgeGraph(); + const sizes = [10, 5, 3]; + const communities: CommunityNode[] = []; + const memberships: CommunityMembership[] = []; + + for (let ci = 0; ci < 3; ci++) { + const commId = `c${ci}`; + communities.push(makeCommunity(commId, `Area${ci}`, sizes[ci])); + for (let ni = 0; ni < sizes[ci]; ni++) { + const nodeId = `fn:c${ci}_n${ni}`; + graph.addNode(makeNode(nodeId, `func_${ci}_${ni}`, 'Function', `${tmpDir}/src/area${ci}/f${ni}.ts`, 1, false)); + memberships.push(makeMembership(nodeId, commId)); + } + } + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toHaveLength(3); + expect(result.skills[0].symbolCount).toBe(10); + expect(result.skills[1].symbolCount).toBe(5); + expect(result.skills[2].symbolCount).toBe(3); + }); + + /** + * When the communities array is empty but memberships exist with nodes + * in an "auth/" folder, the fallback builder should derive a label from + * the most common parent directory. + */ + it('uses fallback builder when communities array is empty', async () => { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:n${i}`, `authFunc${i}`, 'Function', `${tmpDir}/src/auth/file${i}.ts`, 1, true)); + } + + const memberships = [0, 1, 2, 3].map(i => makeMembership(`fn:n${i}`, 'comm_0')); + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities: [], memberships, + })); + + expect(result.skills).toHaveLength(1); + expect(result.skills[0].label).toBe('Auth'); + }); + + /** + * When processResult is undefined, the generator should still work + * without crashing — it simply has no execution flows. + */ + it('does not crash when processResult is undefined', async () => { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:n${i}`, `func${i}`, 'Function', `${tmpDir}/src/core/f${i}.ts`, 1, false)); + } + + const communities = [makeCommunity('c1', 'Core', 4)]; + const memberships = [0, 1, 2, 3].map(i => makeMembership(`fn:n${i}`, 'c1')); + + const pipeline: PipelineResult = { + graph, + repoPath: tmpDir, + totalFileCount: 0, + communityResult: { + communities, + memberships, + stats: { totalCommunities: 1, modularity: 0.5, nodesProcessed: 4 }, + }, + processResult: undefined, + }; + + const result = await generateSkillFiles(tmpDir, 'TestProject', pipeline); + expect(result.skills).toHaveLength(1); + }); + + /** + * Memberships that reference node IDs not present in the graph + * should be silently skipped without crashing. + */ + it('does not crash when memberships reference missing nodes', async () => { + const graph = createKnowledgeGraph(); + // Only add 2 real nodes but membership references 4 + graph.addNode(makeNode('fn:real1', 'real1', 'Function', `${tmpDir}/src/mod/a.ts`, 1, false)); + graph.addNode(makeNode('fn:real2', 'real2', 'Function', `${tmpDir}/src/mod/b.ts`, 1, false)); + + const communities = [makeCommunity('c1', 'Mod', 4)]; + const memberships = [ + makeMembership('fn:real1', 'c1'), + makeMembership('fn:real2', 'c1'), + makeMembership('fn:ghost1', 'c1'), + makeMembership('fn:ghost2', 'c1'), + ]; + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + // Community has symbolCount=4 which passes threshold, but only 2 real nodes resolve + expect(result.skills).toHaveLength(1); + expect(result.skills[0].fileCount).toBe(2); + }); + + /** + * When the same nodeId appears in two raw community IDs that get + * aggregated into the same label, it should not be double-counted + * in the file output. + */ + it('does not double-count nodes shared across aggregated communities', async () => { + const graph = createKnowledgeGraph(); + graph.addNode(makeNode('fn:shared', 'shared', 'Function', `${tmpDir}/src/data/shared.ts`, 1, true)); + graph.addNode(makeNode('fn:a', 'a', 'Function', `${tmpDir}/src/data/a.ts`, 1, false)); + graph.addNode(makeNode('fn:b', 'b', 'Function', `${tmpDir}/src/data/b.ts`, 1, false)); + + // Two raw communities both named "Data", both containing fn:shared + const communities = [ + makeCommunity('c1', 'Data', 2, 0.8), + makeCommunity('c2', 'Data', 2, 0.7), + ]; + const memberships = [ + makeMembership('fn:shared', 'c1'), + makeMembership('fn:a', 'c1'), + makeMembership('fn:shared', 'c2'), + makeMembership('fn:b', 'c2'), + ]; + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toHaveLength(1); + // fileCount should be 3 (shared.ts, a.ts, b.ts) — not 4 + expect(result.skills[0].fileCount).toBe(3); + }); +}); + +// ============================================================================ +// TESTS — FILE OUTPUT +// ============================================================================ + +describe('generateSkillFiles — file output', () => { + let tmpDir: string; + + beforeEach(async () => { + tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-skill-out-')); + vi.spyOn(console, 'log').mockImplementation(() => {}); + }); + + afterEach(async () => { + vi.restoreAllMocks(); + try { + await fs.rm(tmpDir, { recursive: true, force: true }); + } catch { /* best-effort */ } + }); + + /** Helper: create a standard 2-community setup for file-output tests */ + function twoCommSetup() { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:a${i}`, `alphaFn${i}`, 'Function', `${tmpDir}/src/alpha/f${i}.ts`, i * 10 + 1, i < 2)); + } + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:b${i}`, `betaFn${i}`, 'Function', `${tmpDir}/src/beta/f${i}.ts`, i * 10 + 1, i < 2)); + } + + const communities = [ + makeCommunity('cA', 'Alpha', 4, 0.85), + makeCommunity('cB', 'Beta', 4, 0.60), + ]; + const memberships = [ + ...[0, 1, 2, 3].map(i => makeMembership(`fn:a${i}`, 'cA')), + ...[0, 1, 2, 3].map(i => makeMembership(`fn:b${i}`, 'cB')), + ]; + + return { graph, communities, memberships }; + } + + /** + * Verify that each community produces a directory under generated/ + * containing a SKILL.md file. + */ + it('creates generated/{name}/SKILL.md for each community', async () => { + const { graph, communities, memberships } = twoCommSetup(); + + await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + const outputDir = path.join(tmpDir, '.claude', 'skills', 'generated'); + const alphaSkill = await fs.readFile(path.join(outputDir, 'alpha', 'SKILL.md'), 'utf-8'); + const betaSkill = await fs.readFile(path.join(outputDir, 'beta', 'SKILL.md'), 'utf-8'); + expect(alphaSkill.length).toBeGreaterThan(0); + expect(betaSkill.length).toBeGreaterThan(0); + }); + + /** + * SKILL.md files should start with YAML frontmatter containing + * name and description fields. + */ + it('starts with frontmatter containing name and description', async () => { + const { graph, communities, memberships } = twoCommSetup(); + + await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + const content = await fs.readFile( + path.join(tmpDir, '.claude', 'skills', 'generated', 'alpha', 'SKILL.md'), + 'utf-8', + ); + expect(content.startsWith('---')).toBe(true); + expect(content).toContain('name:'); + expect(content).toContain('description:'); + }); + + /** + * A community with exported symbols, processes, and cross-community + * CALLS edges should have all optional sections rendered. + */ + it('includes Entry Points, Execution Flows, Connected Areas when data exists', async () => { + const graph = createKnowledgeGraph(); + // Community A: exported symbols + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:a${i}`, `alphaFn${i}`, 'Function', `${tmpDir}/src/alpha/f${i}.ts`, 1, true)); + } + // Community B: target of cross-community calls + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:b${i}`, `betaFn${i}`, 'Function', `${tmpDir}/src/beta/f${i}.ts`, 1, false)); + } + // Cross-community CALLS edge: A -> B + graph.addRelationship(makeRel('r1', 'fn:a0', 'fn:b0', 'CALLS')); + + const communities = [ + makeCommunity('cA', 'Alpha', 4, 0.85), + makeCommunity('cB', 'Beta', 4, 0.60), + ]; + const memberships = [ + ...[0, 1, 2, 3].map(i => makeMembership(`fn:a${i}`, 'cA')), + ...[0, 1, 2, 3].map(i => makeMembership(`fn:b${i}`, 'cB')), + ]; + + const processes = [makeProcess('p1', 'AlphaFlow', ['cA'], 5)]; + + await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, processes, + })); + + const content = await fs.readFile( + path.join(tmpDir, '.claude', 'skills', 'generated', 'alpha', 'SKILL.md'), + 'utf-8', + ); + + expect(content).toContain('## Entry Points'); + expect(content).toContain('## Execution Flows'); + expect(content).toContain('## Connected Areas'); + }); + + /** + * A community with no exports, no processes, and no cross-community + * calls should omit the optional sections entirely. + */ + it('omits Entry Points, Execution Flows, Connected Areas when absent', async () => { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:n${i}`, `func${i}`, 'Function', `${tmpDir}/src/isolated/f${i}.ts`, 1, false)); + } + + const communities = [makeCommunity('c1', 'Isolated', 4)]; + const memberships = [0, 1, 2, 3].map(i => makeMembership(`fn:n${i}`, 'c1')); + + await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, processes: [], + })); + + const content = await fs.readFile( + path.join(tmpDir, '.claude', 'skills', 'generated', 'isolated', 'SKILL.md'), + 'utf-8', + ); + + expect(content).not.toContain('## Entry Points'); + expect(content).not.toContain('## Execution Flows'); + expect(content).not.toContain('## Connected Areas'); + }); + + /** + * Running generateSkillFiles twice with different communities should + * clean up the first run's output directories. + */ + it('cleans up previous run output on re-run', async () => { + const graph1 = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph1.addNode(makeNode(`fn:x${i}`, `xFunc${i}`, 'Function', `${tmpDir}/src/first/f${i}.ts`, 1, false)); + } + + // First run + await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph: graph1, repoPath: tmpDir, + communities: [makeCommunity('c1', 'First', 4)], + memberships: [0, 1, 2, 3].map(i => makeMembership(`fn:x${i}`, 'c1')), + })); + + const outputDir = path.join(tmpDir, '.claude', 'skills', 'generated'); + const firstRunDirs = await fs.readdir(outputDir); + expect(firstRunDirs).toContain('first'); + + // Second run with different community + const graph2 = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph2.addNode(makeNode(`fn:y${i}`, `yFunc${i}`, 'Function', `${tmpDir}/src/second/f${i}.ts`, 1, false)); + } + + await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph: graph2, repoPath: tmpDir, + communities: [makeCommunity('c2', 'Second', 4)], + memberships: [0, 1, 2, 3].map(i => makeMembership(`fn:y${i}`, 'c2')), + })); + + const secondRunDirs = await fs.readdir(outputDir); + expect(secondRunDirs).toContain('second'); + expect(secondRunDirs).not.toContain('first'); + }); + + /** + * The rendered SKILL.md should contain a stats line matching the + * community's symbol count, file count, and cohesion percentage. + */ + it('contains stats line with correct symbol count, file count, cohesion', async () => { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 5; i++) { + graph.addNode(makeNode(`fn:s${i}`, `statsFn${i}`, 'Function', `${tmpDir}/src/stats/f${i}.ts`, 1, false)); + } + + const communities = [makeCommunity('c1', 'Stats', 5, 0.82)]; + const memberships = [0, 1, 2, 3, 4].map(i => makeMembership(`fn:s${i}`, 'c1')); + + await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + const content = await fs.readFile( + path.join(tmpDir, '.claude', 'skills', 'generated', 'stats', 'SKILL.md'), + 'utf-8', + ); + + expect(content).toContain('5 symbols | 5 files | Cohesion: 82%'); + }); + + /** + * Labels with special characters (like "C++ Core") should be converted + * to a valid kebab-case directory name without crashing. + */ + it('handles special characters in label for directory name', async () => { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:cpp${i}`, `cppFunc${i}`, 'Function', `${tmpDir}/src/cpp/f${i}.ts`, 1, false)); + } + + const communities = [makeCommunity('c1', 'C++ Core', 4)]; + const memberships = [0, 1, 2, 3].map(i => makeMembership(`fn:cpp${i}`, 'c1')); + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toHaveLength(1); + // The kebab name should only contain lowercase alphanumerics and dashes + expect(result.skills[0].name).toMatch(/^[a-z0-9-]+$/); + + const skillPath = path.join(tmpDir, '.claude', 'skills', 'generated', result.skills[0].name, 'SKILL.md'); + const content = await fs.readFile(skillPath, 'utf-8'); + expect(content.length).toBeGreaterThan(0); + }); + + /** + * Nodes with no filePath should not crash the generator. + * The skill should still be generated with fileCount 0. + */ + it('handles nodes with no filePath', async () => { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode(`fn:nf${i}`, `nofileFunc${i}`, 'Function', '', 0, false)); + } + + const communities = [makeCommunity('c1', 'NoFile', 4)]; + const memberships = [0, 1, 2, 3].map(i => makeMembership(`fn:nf${i}`, 'c1')); + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toHaveLength(1); + expect(result.skills[0].fileCount).toBe(0); + }); + + /** + * Node filePaths containing Windows-style backslashes should be + * normalized to forward slashes in the Key Files table (which uses + * toRelativePath). The Key Symbols table renders raw filePath as-is, + * so we only check the Key Files section for normalization. + */ + it('normalizes Windows backslash paths in Key Files output', async () => { + const graph = createKnowledgeGraph(); + for (let i = 0; i < 4; i++) { + graph.addNode(makeNode( + `fn:w${i}`, `winFunc${i}`, 'Function', + `${tmpDir}\\src\\win\\f${i}.ts`, 1, false, + )); + } + + const communities = [makeCommunity('c1', 'Win', 4)]; + const memberships = [0, 1, 2, 3].map(i => makeMembership(`fn:w${i}`, 'c1')); + + const result = await generateSkillFiles(tmpDir, 'TestProject', buildPipelineResult({ + graph, repoPath: tmpDir, communities, memberships, + })); + + expect(result.skills).toHaveLength(1); + + const content = await fs.readFile( + path.join(tmpDir, '.claude', 'skills', 'generated', 'win', 'SKILL.md'), + 'utf-8', + ); + + // Extract the Key Files section between "## Key Files" and the next "##" + const keyFilesMatch = content.match(/## Key Files\n([\s\S]*?)(?=\n##)/); + expect(keyFilesMatch).not.toBeNull(); + const keyFilesSection = keyFilesMatch![1]; + // Key Files section should use forward slashes only + expect(keyFilesSection).not.toMatch(/\\/); + // Verify it actually has file paths + expect(keyFilesSection).toContain('src/win/f0.ts'); + }); +}); diff --git a/gitnexus/test/unit/staleness.test.ts b/gitnexus/test/unit/staleness.test.ts new file mode 100644 index 0000000000..9520841216 --- /dev/null +++ b/gitnexus/test/unit/staleness.test.ts @@ -0,0 +1,67 @@ +/** + * P2 Unit Tests: Staleness Check + * + * Tests: checkStaleness from staleness.ts + * - HEAD matches → not stale + * - HEAD differs → stale with commit count + * - Git failure → fail open (not stale) + */ +import { describe, it, expect, vi, afterEach } from 'vitest'; +import { execFileSync } from 'child_process'; +import { checkStaleness } from '../../src/mcp/staleness.js'; + +// We test checkStaleness with a real git repo (the project itself) +// since mocking execFileSync across ESM modules is complex. + +describe('checkStaleness', () => { + it('returns not stale when HEAD matches lastCommit', () => { + // Get the actual HEAD commit of this repo + let headCommit: string; + try { + headCommit = execFileSync( + 'git', ['rev-parse', 'HEAD'], + { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }, + ).trim(); + } catch { + // If we can't get HEAD (e.g., not in a git repo), skip + return; + } + + const result = checkStaleness(process.cwd(), headCommit); + expect(result.isStale).toBe(false); + expect(result.commitsBehind).toBe(0); + expect(result.hint).toBeUndefined(); + }); + + it('returns stale when lastCommit is behind HEAD', () => { + // Use HEAD~1 — works in shallow clones (GitHub Actions) unlike rev-list --max-parents=0 + let previousCommit: string; + try { + previousCommit = execFileSync( + 'git', ['rev-parse', 'HEAD~1'], + { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }, + ).trim(); + } catch { + return; // Not in a git repo or only 1 commit + } + + if (!previousCommit) return; + + const result = checkStaleness(process.cwd(), previousCommit); + expect(result.isStale).toBe(true); + expect(result.commitsBehind).toBeGreaterThan(0); + expect(result.hint).toContain('behind HEAD'); + }); + + it('fails open when git command fails (e.g., invalid path)', () => { + const result = checkStaleness('/nonexistent/path', 'abc123'); + expect(result.isStale).toBe(false); + expect(result.commitsBehind).toBe(0); + }); + + it('fails open with invalid commit hash', () => { + const result = checkStaleness(process.cwd(), 'not-a-real-commit-hash'); + expect(result.isStale).toBe(false); + expect(result.commitsBehind).toBe(0); + }); +}); diff --git a/gitnexus/test/unit/structure-processor.test.ts b/gitnexus/test/unit/structure-processor.test.ts new file mode 100644 index 0000000000..57b5423ceb --- /dev/null +++ b/gitnexus/test/unit/structure-processor.test.ts @@ -0,0 +1,95 @@ +import { describe, it, expect } from 'vitest'; +import { processStructure } from '../../src/core/ingestion/structure-processor.js'; +import { createKnowledgeGraph } from '../../src/core/graph/graph.js'; + +describe('processStructure', () => { + it('creates File nodes for each path', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['src/index.ts', 'src/utils.ts']); + const fileNodes = graph.nodes.filter(n => n.label === 'File'); + expect(fileNodes).toHaveLength(2); + expect(fileNodes.map(n => n.properties.name)).toContain('index.ts'); + expect(fileNodes.map(n => n.properties.name)).toContain('utils.ts'); + }); + + it('creates Folder nodes for directories', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['src/lib/utils.ts']); + const folderNodes = graph.nodes.filter(n => n.label === 'Folder'); + expect(folderNodes.map(n => n.properties.name)).toContain('src'); + expect(folderNodes.map(n => n.properties.name)).toContain('lib'); + }); + + it('creates CONTAINS relationships from parent to child', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['src/index.ts']); + const rels = graph.relationships.filter(r => r.type === 'CONTAINS'); + expect(rels).toHaveLength(1); + expect(rels[0].sourceId).toBe('Folder:src'); + expect(rels[0].targetId).toBe('File:src/index.ts'); + }); + + it('creates nested folder hierarchy', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['src/core/graph/types.ts']); + const folderNodes = graph.nodes.filter(n => n.label === 'Folder'); + expect(folderNodes).toHaveLength(3); // src, core, graph + const rels = graph.relationships.filter(r => r.type === 'CONTAINS'); + expect(rels).toHaveLength(3); // src->core, core->graph, graph->types.ts + }); + + it('deduplicates shared folders', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['src/a.ts', 'src/b.ts']); + const folderNodes = graph.nodes.filter(n => n.label === 'Folder'); + // 'src' should only appear once + expect(folderNodes.filter(n => n.properties.name === 'src')).toHaveLength(1); + }); + + it('handles single file without directory', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['index.ts']); + expect(graph.nodes).toHaveLength(1); + expect(graph.nodes[0].label).toBe('File'); + expect(graph.relationships).toHaveLength(0); + }); + + it('handles empty paths array', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, []); + expect(graph.nodeCount).toBe(0); + expect(graph.relationshipCount).toBe(0); + }); + + it('sets CONTAINS relationship confidence to 1.0', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['src/index.ts']); + const rels = graph.relationships; + for (const rel of rels) { + expect(rel.confidence).toBe(1.0); + } + }); + + it('stores filePath as the full cumulative path', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['src/core/utils.ts']); + const utils = graph.nodes.find(n => n.properties.name === 'utils.ts'); + expect(utils!.properties.filePath).toBe('src/core/utils.ts'); + const core = graph.nodes.find(n => n.properties.name === 'core'); + expect(core!.properties.filePath).toBe('src/core'); + }); + + it('handles deeply nested paths', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['a/b/c/d/e.ts']); + expect(graph.nodes.filter(n => n.label === 'Folder')).toHaveLength(4); + expect(graph.nodes.filter(n => n.label === 'File')).toHaveLength(1); + }); + + it('generates correct node IDs', () => { + const graph = createKnowledgeGraph(); + processStructure(graph, ['src/index.ts']); + expect(graph.getNode('Folder:src')).toBeDefined(); + expect(graph.getNode('File:src/index.ts')).toBeDefined(); + }); +}); diff --git a/gitnexus/test/unit/suffix-index-ambiguity.test.ts b/gitnexus/test/unit/suffix-index-ambiguity.test.ts new file mode 100644 index 0000000000..3c873f06cb --- /dev/null +++ b/gitnexus/test/unit/suffix-index-ambiguity.test.ts @@ -0,0 +1,252 @@ +/** + * Unit tests for proximity-based Python import resolution. + * + * When two files share the same bare name (e.g. user.py in two different + * directories), suffixResolve alone picks whichever was indexed first. + * resolvePythonImport addresses this by checking the importer's own directory + * first, mirroring Python's sys.path resolution order. + */ + +import { describe, it, expect } from 'vitest'; +import { buildSuffixIndex, suffixResolve } from '../../src/core/ingestion/resolvers/utils.js'; +import { resolvePythonImport } from '../../src/core/ingestion/resolvers/python.js'; +import { resolveImportPath } from '../../src/core/ingestion/resolvers/standard.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +function makeCtx(files: string[]) { + const normalized = files.map(f => f.replace(/\\/g, '/')); + const allFilesSet = new Set(files); + const index = buildSuffixIndex(normalized, files); + const cache = new Map<string, string | null>(); + return { files, normalized, allFilesSet, index, cache }; +} + +/** Simulate the full dispatch: resolvePythonImport first, then suffixResolve fallback. */ +function resolvePython( + currentFile: string, + importPath: string, + ctx: ReturnType<typeof makeCtx>, +): string | null { + const proximity = resolvePythonImport(currentFile, importPath, ctx.allFilesSet); + if (proximity) return proximity; + if (importPath.startsWith('.')) return null; + const pathLike = importPath.replace(/\./g, '/'); + const parts = pathLike.split('/').filter(Boolean); + return suffixResolve(parts, ctx.normalized, ctx.files, ctx.index); +} + +/** For non-Python languages, delegate directly to standard resolveImportPath. */ +function resolve( + currentFile: string, + importPath: string, + language: SupportedLanguages, + ctx: ReturnType<typeof makeCtx>, +): string | null { + return resolveImportPath( + currentFile, + importPath, + ctx.allFilesSet, + ctx.files, + ctx.normalized, + ctx.cache, + language, + null, + ctx.index, + ); +} + +// --------------------------------------------------------------------------- +// Python proximity resolution +// --------------------------------------------------------------------------- + +describe('resolvePythonImport — proximity-based resolution for Python', () => { + it('resolves bare import to same-directory file when multiple files share the name', () => { + const ctx = makeCtx([ + 'app/models/user.py', // indexed first — would win without proximity + 'app/services/user.py', + 'app/services/auth.py', + ]); + + const result = resolvePython('app/services/auth.py', 'user', ctx); + expect(result).toBe('app/services/user.py'); + }); + + it('falls back to suffix index when no same-directory match exists', () => { + const ctx = makeCtx([ + 'app/models/user.py', + 'app/services/auth.py', + ]); + + const result = resolvePython('app/services/auth.py', 'user', ctx); + expect(result).toBe('app/models/user.py'); + }); + + it('handles importer at repo root (no directory) without crashing', () => { + const ctx = makeCtx([ + 'user.py', + 'auth.py', + ]); + + // importerDir is '' — proximity skipped, suffix fallback used + const result = resolvePython('auth.py', 'user', ctx); + expect(result).toBe('user.py'); + }); + + it('does not apply proximity for multi-segment imports (dotted paths)', () => { + const ctx = makeCtx([ + 'app/models/utils/helpers.py', + 'app/services/auth.py', + ]); + + const result = resolvePython('app/services/auth.py', 'utils.helpers', ctx); + expect(result).toBe('app/models/utils/helpers.py'); + }); + + it('resolves same-directory package (user/__init__.py) via proximity', () => { + const ctx = makeCtx([ + 'app/models/user/__init__.py', // indexed first — would win without proximity + 'app/services/user/__init__.py', + 'app/services/auth.py', + ]); + + const result = resolvePython('app/services/auth.py', 'user', ctx); + expect(result).toBe('app/services/user/__init__.py'); + }); + + it('falls back to suffixResolve for __init__.py when no same-directory package exists', () => { + const ctx = makeCtx([ + 'app/models/__init__.py', + 'app/services/auth.py', + ]); + + const result = resolvePython('app/services/auth.py', 'models', ctx); + expect(result).toBe('app/models/__init__.py'); + }); + + it('handles Windows-style backslash paths in currentFile without crashing', () => { + const ctx = makeCtx([ + 'app/services/user.py', + 'app/services/auth.py', + ]); + + const result = resolvePython('app\\services\\auth.py', 'user', ctx); + expect(result).toBe('app/services/user.py'); + }); + + it('resolves PEP 328 relative import (.user) to same-directory file', () => { + const ctx = makeCtx([ + 'app/services/user.py', + 'app/services/auth.py', + ]); + + const result = resolvePython('app/services/auth.py', '.user', ctx); + expect(result).toBe('app/services/user.py'); + }); + + it('returns null when relative import dots exceed directory depth (PEP 328 over-traversal)', () => { + // auth.py is at depth 1 (one directory: 'app'). + // '...user' has 3 dots → 2 upward hops required, but only 1 directory level exists. + // CPython raises ImportError; we return null. + const ctx = makeCtx([ + 'app/auth.py', + 'user.py', + ]); + + const result = resolvePython('app/auth.py', '...user', ctx); + expect(result).toBeNull(); + }); +}); + +// --------------------------------------------------------------------------- +// Namespace packages (PEP 420) — directory with no __init__.py +// --------------------------------------------------------------------------- + +describe('resolvePythonImport — namespace packages (no __init__.py)', () => { + // user/ exists as a namespace package: no __init__.py, only submodules. + const files = [ + 'app/services/auth.py', + 'app/services/user/model.py', // user/ has no __init__.py + 'app/services/user/queries.py', + ]; + + it('bare import of namespace package returns null (no file to resolve to)', () => { + // `import user` — proximity finds neither user.py nor user/__init__.py. + // suffixResolve also finds nothing because no file is literally named "user". + // This is expected: CPython itself sets user.__file__ = None for namespace packages. + const ctx = makeCtx(files); + const result = resolvePython('app/services/auth.py', 'user', ctx); + expect(result).toBeNull(); + }); + + it('submodule form resolves correctly via suffixResolve fallback', () => { + // `import user.model` — multi-segment, proximity skipped, suffixResolve finds user/model.py. + const ctx = makeCtx(files); + const result = resolvePython('app/services/auth.py', 'user.model', ctx); + expect(result).toBe('app/services/user/model.py'); + }); +}); + +// --------------------------------------------------------------------------- +// Ruby: bare require does NOT use proximity +// --------------------------------------------------------------------------- + +describe('resolveImportPath — Ruby bare require does not use proximity', () => { + it('returns first-indexed file for bare require (Ruby $LOAD_PATH excludes current directory)', () => { + const ctx = makeCtx([ + 'lib/core/helpers.rb', // indexed first + 'lib/utils/helpers.rb', + 'lib/utils/formatter.rb', + ]); + + // Ruby bare `require 'helpers'` searches $LOAD_PATH — current directory not included. + // No proximity bias; first-indexed file is returned, same as before. + const result = resolve('lib/utils/formatter.rb', 'helpers', SupportedLanguages.Ruby, ctx); + expect(result).toBe('lib/core/helpers.rb'); + }); + + it('resolves require_relative (dot-prefixed) to same-directory file via generic relative resolver', () => { + const ctx = makeCtx([ + 'lib/utils/helpers.rb', + 'lib/utils/formatter.rb', + ]); + + // require_relative arrives as "./<path>" — caught by generic relative resolver, not proximity + const result = resolve('lib/utils/formatter.rb', './helpers', SupportedLanguages.Ruby, ctx); + expect(result).toBe('lib/utils/helpers.rb'); + }); +}); + +// --------------------------------------------------------------------------- +// Other languages: no proximity applied +// --------------------------------------------------------------------------- + +describe('resolveImportPath — no proximity for Java or TypeScript', () => { + it('Java: fully-qualified import resolves to the correct file via unique suffix', () => { + const ctx = makeCtx([ + 'src/com/a/User.java', + 'src/com/b/User.java', + 'src/com/b/Service.java', + ]); + + // "com.b.User" → "com/b/User" → unique suffix; no ambiguity + const result = resolve('src/com/b/Service.java', 'com.b.User', SupportedLanguages.Java, ctx); + expect(result).toBe('src/com/b/User.java'); + }); + + it('TypeScript: relative import resolves via generic relative resolver', () => { + const ctx = makeCtx([ + 'src/services/user.ts', + 'src/services/auth.ts', + 'src/models/user.ts', + ]); + + // "./user" is explicit relative — resolved before proximity is checked + const result = resolve('src/services/auth.ts', './user', SupportedLanguages.TypeScript, ctx); + expect(result).toBe('src/services/user.ts'); + }); +}); + diff --git a/gitnexus/test/unit/symbol-resolver.test.ts b/gitnexus/test/unit/symbol-resolver.test.ts new file mode 100644 index 0000000000..377349a202 --- /dev/null +++ b/gitnexus/test/unit/symbol-resolver.test.ts @@ -0,0 +1,496 @@ +import { describe, it, expect, beforeEach } from 'vitest'; +import { createResolutionContext, type ResolutionContext } from '../../src/core/ingestion/resolution-context.js'; +import { createSymbolTable } from '../../src/core/ingestion/symbol-table.js'; +import { isFileInPackageDir } from '../../src/core/ingestion/import-processor.js'; + +/** Helper: resolve to single best definition (refuses ambiguous global) */ +const resolveOne = (ctx: ResolutionContext, name: string, fromFile: string) => { + const tiered = ctx.resolve(name, fromFile); + if (!tiered) return null; + if (tiered.tier === 'global' && tiered.candidates.length !== 1) return null; + return tiered.candidates[0]; +}; + +/** Helper: resolve with tier metadata (refuses ambiguous global) */ +const resolveInternal = (ctx: ResolutionContext, name: string, fromFile: string) => { + const tiered = ctx.resolve(name, fromFile); + if (!tiered) return null; + if (tiered.tier === 'global' && tiered.candidates.length !== 1) return null; + return { definition: tiered.candidates[0], tier: tiered.tier, candidateCount: tiered.candidates.length }; +}; + +describe('ResolutionContext.resolve — resolveSymbol compatibility', () => { + let ctx: ResolutionContext; + + beforeEach(() => { + ctx = createResolutionContext(); + }); + + describe('Tier 1: Same-file resolution', () => { + it('resolves symbol defined in the same file', () => { + ctx.symbols.add('src/models/user.ts', 'User', 'Class:src/models/user.ts:User', 'Class'); + + const result = resolveOne(ctx, 'User', 'src/models/user.ts'); + + expect(result).not.toBeNull(); + expect(result!.nodeId).toBe('Class:src/models/user.ts:User'); + expect(result!.filePath).toBe('src/models/user.ts'); + expect(result!.type).toBe('Class'); + }); + + it('prefers same-file over imported definition', () => { + ctx.symbols.add('src/local.ts', 'Config', 'Class:src/local.ts:Config', 'Class'); + ctx.symbols.add('src/shared.ts', 'Config', 'Class:src/shared.ts:Config', 'Class'); + ctx.importMap.set('src/local.ts', new Set(['src/shared.ts'])); + + const result = resolveOne(ctx, 'Config', 'src/local.ts'); + + expect(result!.nodeId).toBe('Class:src/local.ts:Config'); + expect(result!.filePath).toBe('src/local.ts'); + }); + }); + + describe('Tier 2: Import-scoped resolution', () => { + it('resolves symbol from an imported file', () => { + ctx.symbols.add('src/services/auth.ts', 'AuthService', 'Class:src/services/auth.ts:AuthService', 'Class'); + ctx.importMap.set('src/controllers/login.ts', new Set(['src/services/auth.ts'])); + + const result = resolveOne(ctx, 'AuthService', 'src/controllers/login.ts'); + + expect(result).not.toBeNull(); + expect(result!.nodeId).toBe('Class:src/services/auth.ts:AuthService'); + expect(result!.filePath).toBe('src/services/auth.ts'); + }); + + it('prefers imported definition over non-imported with same name', () => { + ctx.symbols.add('src/services/logger.ts', 'Logger', 'Class:src/services/logger.ts:Logger', 'Class'); + ctx.symbols.add('src/testing/mock-logger.ts', 'Logger', 'Class:src/testing/mock-logger.ts:Logger', 'Class'); + ctx.importMap.set('src/app.ts', new Set(['src/services/logger.ts'])); + + const result = resolveOne(ctx, 'Logger', 'src/app.ts'); + + expect(result!.nodeId).toBe('Class:src/services/logger.ts:Logger'); + expect(result!.filePath).toBe('src/services/logger.ts'); + }); + + it('handles file with no imports — unique global falls through', () => { + ctx.symbols.add('src/utils.ts', 'Helper', 'Class:src/utils.ts:Helper', 'Class'); + + const result = resolveOne(ctx, 'Helper', 'src/app.ts'); + + expect(result).not.toBeNull(); + expect(result!.nodeId).toBe('Class:src/utils.ts:Helper'); + }); + }); + + describe('Tier 3: Global resolution', () => { + it('resolves unique global when not in imports', () => { + ctx.symbols.add('src/external/base.ts', 'BaseModel', 'Class:src/external/base.ts:BaseModel', 'Class'); + ctx.importMap.set('src/app.ts', new Set(['src/other.ts'])); + + const result = resolveOne(ctx, 'BaseModel', 'src/app.ts'); + + expect(result).not.toBeNull(); + expect(result!.nodeId).toBe('Class:src/external/base.ts:BaseModel'); + }); + + it('refuses ambiguous global — returns null when multiple candidates exist', () => { + ctx.symbols.add('src/a.ts', 'Config', 'Class:src/a.ts:Config', 'Class'); + ctx.symbols.add('src/b.ts', 'Config', 'Class:src/b.ts:Config', 'Class'); + + const result = resolveOne(ctx, 'Config', 'src/other.ts'); + + expect(result).toBeNull(); + }); + + it('ctx.resolve returns all candidates at global tier (consumers decide)', () => { + ctx.symbols.add('src/a.ts', 'Config', 'Class:src/a.ts:Config', 'Class'); + ctx.symbols.add('src/b.ts', 'Config', 'Class:src/b.ts:Config', 'Class'); + + const tiered = ctx.resolve('Config', 'src/other.ts'); + + expect(tiered).not.toBeNull(); + expect(tiered!.tier).toBe('global'); + expect(tiered!.candidates.length).toBe(2); + }); + }); + + describe('null cases', () => { + it('returns null for unknown symbol', () => { + const result = resolveOne(ctx, 'NonExistent', 'src/app.ts'); + expect(result).toBeNull(); + }); + + it('returns null when symbol table is empty', () => { + const result = resolveOne(ctx, 'Anything', 'src/app.ts'); + expect(result).toBeNull(); + }); + }); + + describe('type preservation', () => { + it('preserves Interface type for heritage resolution', () => { + ctx.symbols.add('src/interfaces.ts', 'ILogger', 'Interface:src/interfaces.ts:ILogger', 'Interface'); + ctx.importMap.set('src/app.ts', new Set(['src/interfaces.ts'])); + + const result = resolveOne(ctx, 'ILogger', 'src/app.ts'); + + expect(result!.type).toBe('Interface'); + }); + + it('preserves Class type for heritage resolution', () => { + ctx.symbols.add('src/base.ts', 'BaseService', 'Class:src/base.ts:BaseService', 'Class'); + ctx.importMap.set('src/app.ts', new Set(['src/base.ts'])); + + const result = resolveOne(ctx, 'BaseService', 'src/app.ts'); + + expect(result!.type).toBe('Class'); + }); + }); + + describe('heritage-specific scenarios', () => { + it('resolves C# interface vs class ambiguity via imports', () => { + ctx.symbols.add('src/logging/ilogger.cs', 'ILogger', 'Interface:src/logging/ilogger.cs:ILogger', 'Interface'); + ctx.symbols.add('src/testing/ilogger.cs', 'ILogger', 'Class:src/testing/ilogger.cs:ILogger', 'Class'); + ctx.importMap.set('src/services/auth.cs', new Set(['src/logging/ilogger.cs'])); + + const result = resolveOne(ctx, 'ILogger', 'src/services/auth.cs'); + + expect(result!.type).toBe('Interface'); + expect(result!.filePath).toBe('src/logging/ilogger.cs'); + }); + + it('resolves parent class from imported file for extends', () => { + ctx.symbols.add('src/api/controller.ts', 'UserController', 'Class:src/api/controller.ts:UserController', 'Class'); + ctx.symbols.add('src/base/controller.ts', 'BaseController', 'Class:src/base/controller.ts:BaseController', 'Class'); + ctx.importMap.set('src/api/controller.ts', new Set(['src/base/controller.ts'])); + + const result = resolveOne(ctx, 'BaseController', 'src/api/controller.ts'); + + expect(result!.nodeId).toBe('Class:src/base/controller.ts:BaseController'); + }); + }); +}); + +describe('ResolutionContext.resolve — tier metadata', () => { + let ctx: ResolutionContext; + + beforeEach(() => { + ctx = createResolutionContext(); + }); + + it('returns same-file tier for Tier 1 match', () => { + ctx.symbols.add('src/a.ts', 'Foo', 'Class:src/a.ts:Foo', 'Class'); + + const result = resolveInternal(ctx, 'Foo', 'src/a.ts'); + + expect(result).not.toBeNull(); + expect(result!.tier).toBe('same-file'); + expect(result!.candidateCount).toBe(1); + expect(result!.definition.nodeId).toBe('Class:src/a.ts:Foo'); + }); + + it('returns import-scoped tier for Tier 2 match', () => { + ctx.symbols.add('src/logger.ts', 'Logger', 'Class:src/logger.ts:Logger', 'Class'); + ctx.symbols.add('src/mock.ts', 'Logger', 'Class:src/mock.ts:Logger', 'Class'); + ctx.importMap.set('src/app.ts', new Set(['src/logger.ts'])); + + const result = resolveInternal(ctx, 'Logger', 'src/app.ts'); + + expect(result).not.toBeNull(); + expect(result!.tier).toBe('import-scoped'); + }); + + it('returns global tier for Tier 3 match', () => { + ctx.symbols.add('src/only.ts', 'Singleton', 'Class:src/only.ts:Singleton', 'Class'); + + const result = resolveInternal(ctx, 'Singleton', 'src/other.ts'); + + expect(result).not.toBeNull(); + expect(result!.tier).toBe('global'); + expect(result!.candidateCount).toBe(1); + }); + + it('returns null for ambiguous global — refuses to guess', () => { + ctx.symbols.add('src/a.ts', 'Config', 'Class:src/a.ts:Config', 'Class'); + ctx.symbols.add('src/b.ts', 'Config', 'Class:src/b.ts:Config', 'Class'); + + const result = resolveInternal(ctx, 'Config', 'src/other.ts'); + + expect(result).toBeNull(); + }); + + it('returns null for unknown symbol', () => { + const result = resolveInternal(ctx, 'Ghost', 'src/any.ts'); + expect(result).toBeNull(); + }); + + it('Tier 1 wins over Tier 2 — same-file takes priority', () => { + ctx.symbols.add('src/app.ts', 'Util', 'Function:src/app.ts:Util', 'Function'); + ctx.symbols.add('src/lib.ts', 'Util', 'Function:src/lib.ts:Util', 'Function'); + ctx.importMap.set('src/app.ts', new Set(['src/lib.ts'])); + + const result = resolveInternal(ctx, 'Util', 'src/app.ts'); + + expect(result!.tier).toBe('same-file'); + expect(result!.definition.filePath).toBe('src/app.ts'); + }); +}); + +describe('negative tests — ambiguous refusal per language family', () => { + let ctx: ResolutionContext; + + beforeEach(() => { + ctx = createResolutionContext(); + }); + + it('TS/JS: two Logger definitions with no import → returns null', () => { + ctx.symbols.add('src/services/logger.ts', 'Logger', 'Class:src/services/logger.ts:Logger', 'Class'); + ctx.symbols.add('src/testing/logger.ts', 'Logger', 'Class:src/testing/logger.ts:Logger', 'Class'); + + const result = resolveOne(ctx, 'Logger', 'src/app.ts'); + expect(result).toBeNull(); + }); + + it('Java: same-named class in different packages, no import → returns null', () => { + ctx.symbols.add('com/example/models/User.java', 'User', 'Class:com/example/models/User.java:User', 'Class'); + ctx.symbols.add('com/example/dto/User.java', 'User', 'Class:com/example/dto/User.java:User', 'Class'); + + const result = resolveOne(ctx, 'User', 'com/example/services/UserService.java'); + expect(result).toBeNull(); + }); + + it('C/C++: type defined in transitively-included header → returns null (not reachable via direct import)', () => { + ctx.symbols.add('src/c.h', 'Widget', 'Struct:src/c.h:Widget', 'Struct'); + ctx.symbols.add('src/d.h', 'Widget', 'Struct:src/d.h:Widget', 'Struct'); + ctx.importMap.set('src/a.c', new Set(['src/b.h'])); + + const result = resolveOne(ctx, 'Widget', 'src/a.c'); + expect(result).toBeNull(); + }); + + it('C#: two IService interfaces in different namespaces, no import → returns null', () => { + ctx.symbols.add('src/Services/IService.cs', 'IService', 'Interface:src/Services/IService.cs:IService', 'Interface'); + ctx.symbols.add('src/Testing/IService.cs', 'IService', 'Interface:src/Testing/IService.cs:IService', 'Interface'); + + const result = resolveOne(ctx, 'IService', 'src/App.cs'); + expect(result).toBeNull(); + }); +}); + +describe('heritage false-positive guard', () => { + let ctx: ResolutionContext; + + beforeEach(() => { + ctx = createResolutionContext(); + }); + + it('null from resolve prevents false edge — generateId fallback produces synthetic ID, not wrong match', () => { + ctx.symbols.add('src/api/base.ts', 'BaseController', 'Class:src/api/base.ts:BaseController', 'Class'); + ctx.symbols.add('src/testing/base.ts', 'BaseController', 'Class:src/testing/base.ts:BaseController', 'Class'); + + const result = resolveOne(ctx, 'BaseController', 'src/routes/admin.ts'); + expect(result).toBeNull(); + + ctx.importMap.set('src/routes/admin.ts', new Set(['src/api/base.ts'])); + const resolved = resolveOne(ctx, 'BaseController', 'src/routes/admin.ts'); + expect(resolved).not.toBeNull(); + expect(resolved!.filePath).toBe('src/api/base.ts'); + }); +}); + +describe('lookupExactFull', () => { + it('returns full SymbolDefinition for same-file lookup via O(1) direct storage', () => { + const symbolTable = createSymbolTable(); + symbolTable.add('src/models/user.ts', 'User', 'Class:src/models/user.ts:User', 'Class'); + + const result = symbolTable.lookupExactFull('src/models/user.ts', 'User'); + + expect(result).not.toBeUndefined(); + expect(result!.nodeId).toBe('Class:src/models/user.ts:User'); + expect(result!.filePath).toBe('src/models/user.ts'); + expect(result!.type).toBe('Class'); + }); + + it('returns undefined for non-existent symbol', () => { + const symbolTable = createSymbolTable(); + const result = symbolTable.lookupExactFull('src/app.ts', 'NonExistent'); + expect(result).toBeUndefined(); + }); + + it('returns undefined for wrong file', () => { + const symbolTable = createSymbolTable(); + symbolTable.add('src/a.ts', 'Foo', 'Class:src/a.ts:Foo', 'Class'); + + const result = symbolTable.lookupExactFull('src/b.ts', 'Foo'); + expect(result).toBeUndefined(); + }); + + it('shares same object reference between fileIndex and globalIndex', () => { + const symbolTable = createSymbolTable(); + symbolTable.add('src/x.ts', 'Bar', 'Class:src/x.ts:Bar', 'Class'); + + const fromExact = symbolTable.lookupExactFull('src/x.ts', 'Bar'); + const fromFuzzy = symbolTable.lookupFuzzy('Bar')[0]; + + expect(fromExact).toBe(fromFuzzy); + }); + + it('preserves optional callable metadata on stored definitions', () => { + const symbolTable = createSymbolTable(); + symbolTable.add('src/math.ts', 'sum', 'Function:src/math.ts:sum', 'Function', { parameterCount: 2 }); + + const fromExact = symbolTable.lookupExactFull('src/math.ts', 'sum'); + const fromFuzzy = symbolTable.lookupFuzzy('sum')[0]; + + expect(fromExact?.parameterCount).toBe(2); + expect(fromFuzzy.parameterCount).toBe(2); + expect(fromExact).toBe(fromFuzzy); + }); +}); + +describe('isFileInPackageDir', () => { + it('matches file directly in the package directory', () => { + expect(isFileInPackageDir('internal/auth/handler.go', '/internal/auth/')).toBe(true); + }); + + it('matches with leading path segments', () => { + expect(isFileInPackageDir('myrepo/internal/auth/handler.go', '/internal/auth/')).toBe(true); + expect(isFileInPackageDir('src/github.com/user/repo/internal/auth/handler.go', '/internal/auth/')).toBe(true); + }); + + it('rejects files in subdirectories', () => { + expect(isFileInPackageDir('internal/auth/middleware/jwt.go', '/internal/auth/')).toBe(false); + }); + + it('matches any file extension in the directory', () => { + expect(isFileInPackageDir('internal/auth/README.md', '/internal/auth/')).toBe(true); + expect(isFileInPackageDir('Models/User.cs', '/Models/')).toBe(true); + expect(isFileInPackageDir('internal/auth/handler_test.go', '/internal/auth/')).toBe(true); + }); + + it('rejects files not in the package', () => { + expect(isFileInPackageDir('internal/db/connection.go', '/internal/auth/')).toBe(false); + }); + + it('handles backslash paths (Windows)', () => { + expect(isFileInPackageDir('internal\\auth\\handler.go', '/internal/auth/')).toBe(true); + }); + + it('matches C# namespace directories', () => { + expect(isFileInPackageDir('MyProject/Models/User.cs', '/MyProject/Models/')).toBe(true); + expect(isFileInPackageDir('MyProject/Models/Order.cs', '/MyProject/Models/')).toBe(true); + expect(isFileInPackageDir('MyProject/Models/Sub/Nested.cs', '/MyProject/Models/')).toBe(false); + }); +}); + +describe('Tier 2b: PackageMap resolution (Go)', () => { + let ctx: ResolutionContext; + + beforeEach(() => { + ctx = createResolutionContext(); + }); + + it('resolves symbol via PackageMap when not in ImportMap', () => { + ctx.symbols.add('internal/auth/handler.go', 'HandleLogin', 'Function:internal/auth/handler.go:HandleLogin', 'Function'); + ctx.packageMap.set('cmd/server/main.go', new Set(['/internal/auth/'])); + + const result = ctx.resolve('HandleLogin', 'cmd/server/main.go'); + + expect(result).not.toBeNull(); + expect(result!.tier).toBe('import-scoped'); + expect(result!.candidates[0].filePath).toBe('internal/auth/handler.go'); + }); + + it('does not resolve symbol from wrong package', () => { + ctx.symbols.add('internal/db/connection.go', 'Connect', 'Function:internal/db/connection.go:Connect', 'Function'); + ctx.packageMap.set('cmd/server/main.go', new Set(['/internal/auth/'])); + + const result = ctx.resolve('Connect', 'cmd/server/main.go'); + + // Not in imported package, single global def → global tier + expect(result).not.toBeNull(); + expect(result!.tier).toBe('global'); + }); + + it('Tier 2a (ImportMap) takes precedence over Tier 2b (PackageMap)', () => { + ctx.symbols.add('internal/auth/handler.go', 'Validate', 'Function:internal/auth/handler.go:Validate', 'Function'); + ctx.symbols.add('internal/db/validator.go', 'Validate', 'Function:internal/db/validator.go:Validate', 'Function'); + + ctx.importMap.set('cmd/server/main.go', new Set(['internal/db/validator.go'])); + ctx.packageMap.set('cmd/server/main.go', new Set(['/internal/auth/'])); + + const result = ctx.resolve('Validate', 'cmd/server/main.go'); + + expect(result).not.toBeNull(); + expect(result!.tier).toBe('import-scoped'); + expect(result!.candidates[0].filePath).toBe('internal/db/validator.go'); + }); + + it('resolves both symbols in same imported package', () => { + ctx.symbols.add('internal/auth/handler.go', 'Run', 'Function:internal/auth/handler.go:Run', 'Function'); + ctx.symbols.add('internal/auth/worker.go', 'Run', 'Function:internal/auth/worker.go:Run', 'Function'); + ctx.packageMap.set('cmd/main.go', new Set(['/internal/auth/'])); + + const result = ctx.resolve('Run', 'cmd/main.go'); + + expect(result).not.toBeNull(); + expect(result!.tier).toBe('import-scoped'); + expect(result!.candidates.length).toBe(2); + }); + + it('returns global without packageMap when ambiguous', () => { + ctx.symbols.add('internal/auth/handler.go', 'X', 'Function:internal/auth/handler.go:X', 'Function'); + ctx.symbols.add('internal/db/handler.go', 'X', 'Function:internal/db/handler.go:X', 'Function'); + + const result = resolveInternal(ctx, 'X', 'cmd/main.go'); + + // No import or package match, 2 candidates → ambiguous → null + expect(result).toBeNull(); + }); +}); + +describe('per-file cache', () => { + let ctx: ResolutionContext; + + beforeEach(() => { + ctx = createResolutionContext(); + }); + + it('caches results per file', () => { + ctx.symbols.add('src/a.ts', 'Foo', 'Class:src/a.ts:Foo', 'Class'); + + ctx.enableCache('src/a.ts'); + const r1 = ctx.resolve('Foo', 'src/a.ts'); + const r2 = ctx.resolve('Foo', 'src/a.ts'); + ctx.clearCache(); + + // Same object reference from cache + expect(r1).toBe(r2); + expect(ctx.getStats().cacheHits).toBe(1); + expect(ctx.getStats().cacheMisses).toBe(1); + }); + + it('resolve works without cache enabled', () => { + ctx.symbols.add('src/a.ts', 'Foo', 'Class:src/a.ts:Foo', 'Class'); + + const result = ctx.resolve('Foo', 'src/a.ts'); + + expect(result).not.toBeNull(); + expect(result!.candidates[0].nodeId).toBe('Class:src/a.ts:Foo'); + expect(ctx.getStats().cacheHits).toBe(0); + }); + + it('cache does not leak across files', () => { + ctx.symbols.add('src/a.ts', 'Foo', 'Class:src/a.ts:Foo', 'Class'); + + ctx.enableCache('src/a.ts'); + ctx.resolve('Foo', 'src/a.ts'); // cached for a.ts + + // Resolve from different file — should NOT use cache + const r = ctx.resolve('Foo', 'src/b.ts'); + ctx.clearCache(); + + // Foo is not in src/b.ts, so same-file fails. Falls to global with 1 candidate. + expect(r!.tier).toBe('global'); + }); +}); diff --git a/gitnexus/test/unit/symbol-table.test.ts b/gitnexus/test/unit/symbol-table.test.ts new file mode 100644 index 0000000000..e1dc2b8da6 --- /dev/null +++ b/gitnexus/test/unit/symbol-table.test.ts @@ -0,0 +1,555 @@ +import { describe, it, expect, beforeEach } from 'vitest'; +import { createSymbolTable, type SymbolTable } from '../../src/core/ingestion/symbol-table.js'; + +describe('SymbolTable', () => { + let table: SymbolTable; + + beforeEach(() => { + table = createSymbolTable(); + }); + + describe('add', () => { + it('registers a symbol in the table', () => { + table.add('src/index.ts', 'main', 'func:main', 'Function'); + expect(table.getStats().globalSymbolCount).toBe(1); + expect(table.getStats().fileCount).toBe(1); + }); + + it('handles multiple symbols in the same file', () => { + table.add('src/index.ts', 'main', 'func:main', 'Function'); + table.add('src/index.ts', 'helper', 'func:helper', 'Function'); + expect(table.getStats().fileCount).toBe(1); + expect(table.getStats().globalSymbolCount).toBe(2); + }); + + it('handles same name in different files', () => { + table.add('src/a.ts', 'init', 'func:a:init', 'Function'); + table.add('src/b.ts', 'init', 'func:b:init', 'Function'); + expect(table.getStats().fileCount).toBe(2); + // Global index groups by name, so 'init' has one entry with two definitions + expect(table.getStats().globalSymbolCount).toBe(1); + }); + + it('allows duplicate adds for same file and name', () => { + table.add('src/a.ts', 'foo', 'func:foo:1', 'Function'); + table.add('src/a.ts', 'foo', 'func:foo:2', 'Function'); + // File index overwrites: last wins + expect(table.lookupExact('src/a.ts', 'foo')).toBe('func:foo:2'); + // Global index appends + expect(table.lookupFuzzy('foo')).toHaveLength(2); + }); + }); + + describe('lookupExact', () => { + it('finds a symbol by file path and name', () => { + table.add('src/index.ts', 'main', 'func:main', 'Function'); + expect(table.lookupExact('src/index.ts', 'main')).toBe('func:main'); + }); + + it('returns undefined for unknown file', () => { + table.add('src/index.ts', 'main', 'func:main', 'Function'); + expect(table.lookupExact('src/other.ts', 'main')).toBeUndefined(); + }); + + it('returns undefined for unknown symbol name', () => { + table.add('src/index.ts', 'main', 'func:main', 'Function'); + expect(table.lookupExact('src/index.ts', 'notExist')).toBeUndefined(); + }); + + it('returns undefined for empty table', () => { + expect(table.lookupExact('src/index.ts', 'main')).toBeUndefined(); + }); + }); + + describe('lookupFuzzy', () => { + it('finds all definitions of a symbol across files', () => { + table.add('src/a.ts', 'render', 'func:a:render', 'Function'); + table.add('src/b.ts', 'render', 'func:b:render', 'Method'); + const results = table.lookupFuzzy('render'); + expect(results).toHaveLength(2); + expect(results[0]).toEqual({ nodeId: 'func:a:render', filePath: 'src/a.ts', type: 'Function' }); + expect(results[1]).toEqual({ nodeId: 'func:b:render', filePath: 'src/b.ts', type: 'Method' }); + }); + + it('returns empty array for unknown symbol', () => { + expect(table.lookupFuzzy('nonexistent')).toEqual([]); + }); + + it('returns empty array for empty table', () => { + expect(table.lookupFuzzy('anything')).toEqual([]); + }); + }); + + describe('getStats', () => { + it('returns zero counts for empty table', () => { + expect(table.getStats()).toEqual({ fileCount: 0, globalSymbolCount: 0 }); + }); + + it('tracks unique file count correctly', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + table.add('src/a.ts', 'bar', 'func:bar', 'Function'); + table.add('src/b.ts', 'baz', 'func:baz', 'Function'); + expect(table.getStats().fileCount).toBe(2); + }); + + it('tracks unique global symbol names', () => { + table.add('src/a.ts', 'foo', 'func:a:foo', 'Function'); + table.add('src/b.ts', 'foo', 'func:b:foo', 'Function'); + table.add('src/a.ts', 'bar', 'func:a:bar', 'Function'); + // 'foo' and 'bar' are 2 unique global names + expect(table.getStats().globalSymbolCount).toBe(2); + }); + }); + + describe('returnType metadata', () => { + it('stores returnType in SymbolDefinition', () => { + table.add('src/utils.ts', 'getUser', 'func:getUser', 'Function', { returnType: 'User' }); + const def = table.lookupExactFull('src/utils.ts', 'getUser'); + expect(def).toBeDefined(); + expect(def!.returnType).toBe('User'); + }); + + it('returnType is available via lookupFuzzy', () => { + table.add('src/utils.ts', 'getUser', 'func:getUser', 'Function', { returnType: 'Promise<User>' }); + const results = table.lookupFuzzy('getUser'); + expect(results).toHaveLength(1); + expect(results[0].returnType).toBe('Promise<User>'); + }); + + it('omits returnType when not provided', () => { + table.add('src/utils.ts', 'helper', 'func:helper', 'Function'); + const def = table.lookupExactFull('src/utils.ts', 'helper'); + expect(def).toBeDefined(); + expect(def!.returnType).toBeUndefined(); + }); + + it('stores returnType alongside parameterCount and ownerId', () => { + table.add('src/models.ts', 'save', 'method:save', 'Method', { + parameterCount: 1, + returnType: 'boolean', + ownerId: 'class:User', + }); + const def = table.lookupExactFull('src/models.ts', 'save'); + expect(def).toBeDefined(); + expect(def!.parameterCount).toBe(1); + expect(def!.returnType).toBe('boolean'); + expect(def!.ownerId).toBe('class:User'); + }); + }); + + describe('declaredType metadata', () => { + it('stores declaredType in SymbolDefinition', () => { + table.add('src/models.ts', 'address', 'prop:address', 'Property', { + declaredType: 'Address', + ownerId: 'class:User', + }); + const def = table.lookupExactFull('src/models.ts', 'address'); + expect(def).toBeDefined(); + expect(def!.declaredType).toBe('Address'); + }); + + it('omits declaredType when not provided', () => { + table.add('src/models.ts', 'name', 'prop:name', 'Property', { ownerId: 'class:User' }); + const def = table.lookupExactFull('src/models.ts', 'name'); + expect(def).toBeDefined(); + expect(def!.declaredType).toBeUndefined(); + }); + }); + + describe('Property exclusion from globalIndex', () => { + it('Property with ownerId is NOT added to globalIndex', () => { + table.add('src/models.ts', 'name', 'prop:name', 'Property', { + declaredType: 'string', + ownerId: 'class:User', + }); + // Should not appear in fuzzy lookup + expect(table.lookupFuzzy('name')).toEqual([]); + // But should still be in fileIndex + expect(table.lookupExact('src/models.ts', 'name')).toBe('prop:name'); + }); + + it('Property without ownerId IS added to globalIndex', () => { + table.add('src/models.ts', 'name', 'prop:name', 'Property'); + expect(table.lookupFuzzy('name')).toHaveLength(1); + }); + + it('Property without declaredType is still added to fieldByOwner index only (not globalIndex)', () => { + table.add('src/models.ts', 'name', 'prop:name', 'Property', { ownerId: 'class:User' }); + // No declaredType → still indexed in fieldByOwner (for write-access tracking + // in dynamically-typed languages like Ruby/JS), but excluded from globalIndex + expect(table.lookupFuzzy('name')).toEqual([]); + expect(table.lookupFieldByOwner('class:User', 'name')).toEqual({ + nodeId: 'prop:name', + filePath: 'src/models.ts', + type: 'Property', + ownerId: 'class:User', + }); + }); + + it('non-Property types are always added to globalIndex', () => { + table.add('src/models.ts', 'save', 'method:save', 'Method', { ownerId: 'class:User' }); + expect(table.lookupFuzzy('save')).toHaveLength(1); + }); + }); + + describe('conditional callableIndex invalidation', () => { + it('adding a Function invalidates callableIndex', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function', { returnType: 'void' }); + // First call builds the index + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + // Add another callable — should invalidate and rebuild + table.add('src/a.ts', 'bar', 'func:bar', 'Method'); + expect(table.lookupFuzzyCallable('bar')).toHaveLength(1); + }); + + it('adding a Property does NOT invalidate callableIndex', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + // Build callable index + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + // Add a Property — callable index should still be valid (foo still found) + table.add('src/models.ts', 'name', 'prop:name', 'Property', { + declaredType: 'string', + ownerId: 'class:User', + }); + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + }); + + it('adding a Class does NOT invalidate callableIndex', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + table.add('src/models.ts', 'User', 'class:User', 'Class'); + // Class is not callable, should not trigger rebuild + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + }); + }); + + describe('lookupFieldByOwner', () => { + it('finds a Property by ownerNodeId and fieldName', () => { + table.add('src/models.ts', 'address', 'prop:address', 'Property', { + declaredType: 'Address', + ownerId: 'class:User', + }); + const def = table.lookupFieldByOwner('class:User', 'address'); + expect(def).toBeDefined(); + expect(def!.declaredType).toBe('Address'); + expect(def!.nodeId).toBe('prop:address'); + }); + + it('returns undefined for unknown owner', () => { + table.add('src/models.ts', 'address', 'prop:address', 'Property', { + declaredType: 'Address', + ownerId: 'class:User', + }); + expect(table.lookupFieldByOwner('class:Unknown', 'address')).toBeUndefined(); + }); + + it('returns undefined for unknown field name', () => { + table.add('src/models.ts', 'address', 'prop:address', 'Property', { + declaredType: 'Address', + ownerId: 'class:User', + }); + expect(table.lookupFieldByOwner('class:User', 'email')).toBeUndefined(); + }); + + it('returns undefined for empty table', () => { + expect(table.lookupFieldByOwner('class:User', 'name')).toBeUndefined(); + }); + + it('indexes Property without declaredType (for dynamic language write-access)', () => { + table.add('src/models.ts', 'name', 'prop:name', 'Property', { ownerId: 'class:User' }); + expect(table.lookupFieldByOwner('class:User', 'name')).toEqual({ + nodeId: 'prop:name', + filePath: 'src/models.ts', + type: 'Property', + ownerId: 'class:User', + }); + }); + + it('distinguishes fields by owner', () => { + table.add('src/models.ts', 'name', 'prop:user:name', 'Property', { + declaredType: 'string', + ownerId: 'class:User', + }); + table.add('src/models.ts', 'name', 'prop:repo:name', 'Property', { + declaredType: 'RepoName', + ownerId: 'class:Repo', + }); + expect(table.lookupFieldByOwner('class:User', 'name')!.declaredType).toBe('string'); + expect(table.lookupFieldByOwner('class:Repo', 'name')!.declaredType).toBe('RepoName'); + }); + }); + + describe('lookupFuzzyCallable', () => { + it('returns only callable types (Function, Method, Constructor)', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + table.add('src/a.ts', 'bar', 'method:bar', 'Method'); + table.add('src/a.ts', 'Baz', 'ctor:Baz', 'Constructor'); + table.add('src/a.ts', 'User', 'class:User', 'Class'); + table.add('src/a.ts', 'IUser', 'iface:IUser', 'Interface'); + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + expect(table.lookupFuzzyCallable('bar')).toHaveLength(1); + expect(table.lookupFuzzyCallable('Baz')).toHaveLength(1); + expect(table.lookupFuzzyCallable('User')).toEqual([]); + expect(table.lookupFuzzyCallable('IUser')).toEqual([]); + }); + + it('returns empty array for unknown name', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + expect(table.lookupFuzzyCallable('unknown')).toEqual([]); + }); + + it('rebuilds index after adding new callable', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + expect(table.lookupFuzzyCallable('bar')).toEqual([]); + table.add('src/a.ts', 'bar', 'func:bar', 'Function'); + expect(table.lookupFuzzyCallable('bar')).toHaveLength(1); + }); + + it('filters non-callable types from mixed name entries', () => { + table.add('src/a.ts', 'save', 'func:save', 'Function'); + table.add('src/b.ts', 'save', 'class:save', 'Class'); + const callables = table.lookupFuzzyCallable('save'); + expect(callables).toHaveLength(1); + expect(callables[0].type).toBe('Function'); + }); + }); + + describe('clear', () => { + it('resets all state including fieldByOwner', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + table.add('src/b.ts', 'bar', 'func:bar', 'Function'); + table.add('src/models.ts', 'address', 'prop:address', 'Property', { + declaredType: 'Address', + ownerId: 'class:User', + }); + table.clear(); + expect(table.getStats()).toEqual({ fileCount: 0, globalSymbolCount: 0 }); + expect(table.lookupExact('src/a.ts', 'foo')).toBeUndefined(); + expect(table.lookupFuzzy('foo')).toEqual([]); + expect(table.lookupFieldByOwner('class:User', 'address')).toBeUndefined(); + expect(table.lookupFuzzyCallable('foo')).toEqual([]); + }); + + it('allows re-adding after clear', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + table.clear(); + table.add('src/b.ts', 'bar', 'func:bar', 'Function'); + expect(table.getStats()).toEqual({ fileCount: 1, globalSymbolCount: 1 }); + }); + + it('resets callableIndex so first lookup after clear rebuilds from scratch', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + // Populate the lazy callable index + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + table.clear(); + // After clear the callable index must be gone — empty table returns nothing + expect(table.lookupFuzzyCallable('foo')).toEqual([]); + // Re-adding and looking up rebuilds successfully + table.add('src/a.ts', 'foo', 'func:foo2', 'Function'); + expect(table.lookupFuzzyCallable('foo')).toHaveLength(1); + expect(table.lookupFuzzyCallable('foo')[0].nodeId).toBe('func:foo2'); + }); + }); + + describe('metadata spread branches (individual optional fields)', () => { + it('stores only parameterCount when no other metadata is given', () => { + table.add('src/utils.ts', 'compute', 'func:compute', 'Function', { parameterCount: 3 }); + const def = table.lookupExactFull('src/utils.ts', 'compute'); + expect(def).toBeDefined(); + expect(def!.parameterCount).toBe(3); + expect(def!.returnType).toBeUndefined(); + expect(def!.declaredType).toBeUndefined(); + expect(def!.ownerId).toBeUndefined(); + }); + + it('stores only ownerId on a Method (non-Property) — still added to globalIndex', () => { + table.add('src/models.ts', 'save', 'method:save', 'Method', { ownerId: 'class:Repo' }); + const def = table.lookupExactFull('src/models.ts', 'save'); + expect(def).toBeDefined(); + expect(def!.ownerId).toBe('class:Repo'); + expect(def!.parameterCount).toBeUndefined(); + expect(def!.returnType).toBeUndefined(); + expect(def!.declaredType).toBeUndefined(); + // Non-Property with ownerId must still appear in globalIndex + expect(table.lookupFuzzy('save')).toHaveLength(1); + }); + + it('stores declaredType alone (no ownerId) — symbol goes to globalIndex', () => { + // A Variable/Property without an owner should still be globally visible + table.add('src/config.ts', 'DEFAULT_TIMEOUT', 'var:DEFAULT_TIMEOUT', 'Variable', { + declaredType: 'number', + }); + const def = table.lookupExactFull('src/config.ts', 'DEFAULT_TIMEOUT'); + expect(def).toBeDefined(); + expect(def!.declaredType).toBe('number'); + expect(def!.ownerId).toBeUndefined(); + // No ownerId → not a Property exclusion path → must be in globalIndex + expect(table.lookupFuzzy('DEFAULT_TIMEOUT')).toHaveLength(1); + expect(table.lookupFuzzy('DEFAULT_TIMEOUT')[0].declaredType).toBe('number'); + }); + + it('stores all four optional metadata fields simultaneously on a Method', () => { + table.add('src/models.ts', 'find', 'method:find', 'Method', { + parameterCount: 2, + returnType: 'User | undefined', + declaredType: 'QueryResult', + ownerId: 'class:UserRepository', + }); + const def = table.lookupExactFull('src/models.ts', 'find'); + expect(def).toBeDefined(); + expect(def!.parameterCount).toBe(2); + expect(def!.returnType).toBe('User | undefined'); + expect(def!.declaredType).toBe('QueryResult'); + expect(def!.ownerId).toBe('class:UserRepository'); + }); + + it('omits all optional fields when metadata is not provided at all', () => { + table.add('src/utils.ts', 'noop', 'func:noop', 'Function'); + const def = table.lookupExactFull('src/utils.ts', 'noop'); + expect(def).toBeDefined(); + expect(def!.parameterCount).toBeUndefined(); + expect(def!.returnType).toBeUndefined(); + expect(def!.declaredType).toBeUndefined(); + expect(def!.ownerId).toBeUndefined(); + }); + + it('stores parameterCount: 0 (falsy value) correctly', () => { + // parameterCount of 0 must not be dropped by the spread guard + table.add('src/utils.ts', 'noArgs', 'func:noArgs', 'Function', { parameterCount: 0 }); + const def = table.lookupExactFull('src/utils.ts', 'noArgs'); + expect(def).toBeDefined(); + expect(def!.parameterCount).toBe(0); + }); + }); + + describe('lookupFuzzyCallable — lazy index behaviour', () => { + it('returns empty array when table has no callables', () => { + table.add('src/models.ts', 'User', 'class:User', 'Class'); + table.add('src/models.ts', 'IUser', 'iface:IUser', 'Interface'); + expect(table.lookupFuzzyCallable('User')).toEqual([]); + expect(table.lookupFuzzyCallable('IUser')).toEqual([]); + }); + + it('uses cached index on second call without adding new symbols', () => { + table.add('src/a.ts', 'fetch', 'func:fetch', 'Function', { returnType: 'Response' }); + // First call — builds the lazy index + const first = table.lookupFuzzyCallable('fetch'); + expect(first).toHaveLength(1); + // Second call — must return equivalent result from cache + const second = table.lookupFuzzyCallable('fetch'); + expect(second).toHaveLength(1); + expect(second[0].nodeId).toBe('func:fetch'); + // Both calls return the same array reference (same cache entry) + expect(first).toBe(second); + }); + + it('invalidated cache is rebuilt correctly after adding a Method', () => { + table.add('src/a.ts', 'alpha', 'func:alpha', 'Function'); + // Warm the cache + expect(table.lookupFuzzyCallable('alpha')).toHaveLength(1); + expect(table.lookupFuzzyCallable('beta')).toEqual([]); + // Add a Method — must invalidate cache + table.add('src/a.ts', 'beta', 'method:beta', 'Method'); + // Rebuilt cache must now include beta + const result = table.lookupFuzzyCallable('beta'); + expect(result).toHaveLength(1); + expect(result[0].type).toBe('Method'); + }); + + it('invalidated cache is rebuilt correctly after adding a Constructor', () => { + table.add('src/a.ts', 'existing', 'func:existing', 'Function'); + expect(table.lookupFuzzyCallable('existing')).toHaveLength(1); + table.add('src/models.ts', 'MyClass', 'ctor:MyClass', 'Constructor'); + expect(table.lookupFuzzyCallable('MyClass')).toHaveLength(1); + expect(table.lookupFuzzyCallable('MyClass')[0].type).toBe('Constructor'); + }); + }); + + describe('lookupExactFull — full SymbolDefinition shape', () => { + it('returns undefined for unknown file', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + expect(table.lookupExactFull('src/other.ts', 'foo')).toBeUndefined(); + }); + + it('returns undefined for unknown symbol name within a known file', () => { + table.add('src/a.ts', 'foo', 'func:foo', 'Function'); + expect(table.lookupExactFull('src/a.ts', 'bar')).toBeUndefined(); + }); + + it('returns undefined for empty table', () => { + expect(table.lookupExactFull('src/a.ts', 'foo')).toBeUndefined(); + }); + + it('returns the full SymbolDefinition including nodeId, filePath, and type', () => { + table.add('src/models.ts', 'address', 'prop:address', 'Property', { + declaredType: 'Address', + ownerId: 'class:User', + }); + const def = table.lookupExactFull('src/models.ts', 'address'); + expect(def).toBeDefined(); + expect(def!.nodeId).toBe('prop:address'); + expect(def!.filePath).toBe('src/models.ts'); + expect(def!.type).toBe('Property'); + expect(def!.declaredType).toBe('Address'); + expect(def!.ownerId).toBe('class:User'); + }); + + it('last-write-wins when same file and name are added twice', () => { + table.add('src/a.ts', 'foo', 'func:foo:v1', 'Function', { returnType: 'void' }); + table.add('src/a.ts', 'foo', 'func:foo:v2', 'Function', { returnType: 'string' }); + const def = table.lookupExactFull('src/a.ts', 'foo'); + expect(def).toBeDefined(); + expect(def!.nodeId).toBe('func:foo:v2'); + expect(def!.returnType).toBe('string'); + }); + }); + + describe('lookupFieldByOwner — additional coverage', () => { + it('stores multiple distinct fields under the same owner', () => { + table.add('src/models.ts', 'id', 'prop:user:id', 'Property', { + declaredType: 'number', + ownerId: 'class:User', + }); + table.add('src/models.ts', 'email', 'prop:user:email', 'Property', { + declaredType: 'string', + ownerId: 'class:User', + }); + table.add('src/models.ts', 'createdAt', 'prop:user:createdAt', 'Property', { + declaredType: 'Date', + ownerId: 'class:User', + }); + expect(table.lookupFieldByOwner('class:User', 'id')!.declaredType).toBe('number'); + expect(table.lookupFieldByOwner('class:User', 'email')!.declaredType).toBe('string'); + expect(table.lookupFieldByOwner('class:User', 'createdAt')!.declaredType).toBe('Date'); + }); + + it('returns the full SymbolDefinition (nodeId + filePath + type) not just declaredType', () => { + table.add('src/models.ts', 'score', 'prop:score', 'Property', { + declaredType: 'number', + ownerId: 'class:Player', + }); + const def = table.lookupFieldByOwner('class:Player', 'score'); + expect(def).toBeDefined(); + expect(def!.nodeId).toBe('prop:score'); + expect(def!.filePath).toBe('src/models.ts'); + expect(def!.type).toBe('Property'); + }); + + it('key collision is impossible between different owners sharing a field name', () => { + // Ensures the null-byte separator in the key prevents cross-owner leakage + table.add('src/models.ts', 'id', 'prop:a:id', 'Property', { + declaredType: 'string', + ownerId: 'class:A', + }); + table.add('src/models.ts', 'id', 'prop:b:id', 'Property', { + declaredType: 'UUID', + ownerId: 'class:B', + }); + expect(table.lookupFieldByOwner('class:A', 'id')!.nodeId).toBe('prop:a:id'); + expect(table.lookupFieldByOwner('class:B', 'id')!.nodeId).toBe('prop:b:id'); + // An owner whose id is the concatenation of A's ownerId + fieldName must not match + expect(table.lookupFieldByOwner('class:A\0id', '')).toBeUndefined(); + }); + }); +}); diff --git a/gitnexus/test/unit/tools.test.ts b/gitnexus/test/unit/tools.test.ts new file mode 100644 index 0000000000..f777f572a6 --- /dev/null +++ b/gitnexus/test/unit/tools.test.ts @@ -0,0 +1,102 @@ +/** + * Unit Tests: MCP Tool Definitions + * + * Tests: GITNEXUS_TOOLS from tools.ts + * - All 7 tools are defined + * - Each tool has valid name, description, inputSchema + * - Required fields are correct + * - Optional repo parameter is present on tools that need it + */ +import { describe, it, expect } from 'vitest'; +import { GITNEXUS_TOOLS, type ToolDefinition } from '../../src/mcp/tools.js'; + +describe('GITNEXUS_TOOLS', () => { + it('exports exactly 7 tools', () => { + expect(GITNEXUS_TOOLS).toHaveLength(7); + }); + + it('contains all expected tool names', () => { + const names = GITNEXUS_TOOLS.map(t => t.name); + expect(names).toEqual( + expect.arrayContaining([ + 'list_repos', 'query', 'cypher', 'context', + 'detect_changes', 'rename', 'impact', + ]) + ); + }); + + it('each tool has name, description, and inputSchema', () => { + for (const tool of GITNEXUS_TOOLS) { + expect(tool.name).toBeTruthy(); + expect(typeof tool.name).toBe('string'); + expect(tool.description).toBeTruthy(); + expect(typeof tool.description).toBe('string'); + expect(tool.inputSchema).toBeDefined(); + expect(tool.inputSchema.type).toBe('object'); + expect(tool.inputSchema.properties).toBeDefined(); + expect(Array.isArray(tool.inputSchema.required)).toBe(true); + } + }); + + it('query tool requires "query" parameter', () => { + const queryTool = GITNEXUS_TOOLS.find(t => t.name === 'query')!; + expect(queryTool.inputSchema.required).toContain('query'); + expect(queryTool.inputSchema.properties.query).toBeDefined(); + expect(queryTool.inputSchema.properties.query.type).toBe('string'); + }); + + it('cypher tool requires "query" parameter', () => { + const cypherTool = GITNEXUS_TOOLS.find(t => t.name === 'cypher')!; + expect(cypherTool.inputSchema.required).toContain('query'); + }); + + it('context tool has no required parameters', () => { + const contextTool = GITNEXUS_TOOLS.find(t => t.name === 'context')!; + expect(contextTool.inputSchema.required).toEqual([]); + }); + + it('impact tool requires target and direction', () => { + const impactTool = GITNEXUS_TOOLS.find(t => t.name === 'impact')!; + expect(impactTool.inputSchema.required).toContain('target'); + expect(impactTool.inputSchema.required).toContain('direction'); + }); + + it('rename tool requires new_name', () => { + const renameTool = GITNEXUS_TOOLS.find(t => t.name === 'rename')!; + expect(renameTool.inputSchema.required).toContain('new_name'); + }); + + it('detect_changes tool has no required parameters', () => { + const detectTool = GITNEXUS_TOOLS.find(t => t.name === 'detect_changes')!; + expect(detectTool.inputSchema.required).toEqual([]); + }); + + it('list_repos tool has no parameters', () => { + const listTool = GITNEXUS_TOOLS.find(t => t.name === 'list_repos')!; + expect(Object.keys(listTool.inputSchema.properties)).toHaveLength(0); + expect(listTool.inputSchema.required).toEqual([]); + }); + + it('all tools except list_repos have optional repo parameter', () => { + for (const tool of GITNEXUS_TOOLS) { + if (tool.name === 'list_repos') continue; + expect(tool.inputSchema.properties.repo).toBeDefined(); + expect(tool.inputSchema.properties.repo.type).toBe('string'); + // repo should never be required + expect(tool.inputSchema.required).not.toContain('repo'); + } + }); + + it('detect_changes scope has correct enum values', () => { + const detectTool = GITNEXUS_TOOLS.find(t => t.name === 'detect_changes')!; + const scopeProp = detectTool.inputSchema.properties.scope; + expect(scopeProp.enum).toEqual(['unstaged', 'staged', 'all', 'compare']); + }); + + it('impact relationTypes is array of strings', () => { + const impactTool = GITNEXUS_TOOLS.find(t => t.name === 'impact')!; + const relProp = impactTool.inputSchema.properties.relationTypes; + expect(relProp.type).toBe('array'); + expect(relProp.items).toEqual({ type: 'string' }); + }); +}); diff --git a/gitnexus/test/unit/tree-sitter-queries.test.ts b/gitnexus/test/unit/tree-sitter-queries.test.ts new file mode 100644 index 0000000000..18c2a3ae61 --- /dev/null +++ b/gitnexus/test/unit/tree-sitter-queries.test.ts @@ -0,0 +1,317 @@ +import { describe, it, expect } from 'vitest'; +import { + TYPESCRIPT_QUERIES, + JAVASCRIPT_QUERIES, + PYTHON_QUERIES, + JAVA_QUERIES, + C_QUERIES, + GO_QUERIES, + CPP_QUERIES, + CSHARP_QUERIES, + RUST_QUERIES, + PHP_QUERIES, + SWIFT_QUERIES, + LANGUAGE_QUERIES, +} from '../../src/core/ingestion/tree-sitter-queries.js'; +import { SupportedLanguages } from '../../src/config/supported-languages.js'; + +describe('tree-sitter queries', () => { + describe('LANGUAGE_QUERIES map', () => { + it('has entries for all supported languages', () => { + const allLanguages = Object.values(SupportedLanguages); + for (const lang of allLanguages) { + expect(LANGUAGE_QUERIES[lang]).toBeDefined(); + expect(LANGUAGE_QUERIES[lang].length).toBeGreaterThan(0); + } + }); + + it('maps to the correct query constants', () => { + expect(LANGUAGE_QUERIES[SupportedLanguages.TypeScript]).toBe(TYPESCRIPT_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.JavaScript]).toBe(JAVASCRIPT_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.Python]).toBe(PYTHON_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.Java]).toBe(JAVA_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.C]).toBe(C_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.Go]).toBe(GO_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.CPlusPlus]).toBe(CPP_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.CSharp]).toBe(CSHARP_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.Rust]).toBe(RUST_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.PHP]).toBe(PHP_QUERIES); + expect(LANGUAGE_QUERIES[SupportedLanguages.Swift]).toBe(SWIFT_QUERIES); + }); + }); + + describe('TypeScript queries', () => { + it('captures class declarations', () => { + expect(TYPESCRIPT_QUERIES).toContain('class_declaration'); + expect(TYPESCRIPT_QUERIES).toContain('@definition.class'); + }); + + it('captures interface declarations', () => { + expect(TYPESCRIPT_QUERIES).toContain('interface_declaration'); + expect(TYPESCRIPT_QUERIES).toContain('@definition.interface'); + }); + + it('captures function declarations', () => { + expect(TYPESCRIPT_QUERIES).toContain('function_declaration'); + expect(TYPESCRIPT_QUERIES).toContain('@definition.function'); + }); + + it('captures method definitions', () => { + expect(TYPESCRIPT_QUERIES).toContain('method_definition'); + expect(TYPESCRIPT_QUERIES).toContain('@definition.method'); + }); + + it('captures arrow functions in variable declarations', () => { + expect(TYPESCRIPT_QUERIES).toContain('arrow_function'); + }); + + it('captures imports', () => { + expect(TYPESCRIPT_QUERIES).toContain('import_statement'); + expect(TYPESCRIPT_QUERIES).toContain('@import'); + }); + + it('captures call expressions', () => { + expect(TYPESCRIPT_QUERIES).toContain('call_expression'); + expect(TYPESCRIPT_QUERIES).toContain('@call'); + }); + + it('captures heritage (extends/implements)', () => { + expect(TYPESCRIPT_QUERIES).toContain('@heritage.extends'); + expect(TYPESCRIPT_QUERIES).toContain('@heritage.implements'); + }); + }); + + describe('JavaScript queries', () => { + it('captures function and class definitions', () => { + expect(JAVASCRIPT_QUERIES).toContain('@definition.class'); + expect(JAVASCRIPT_QUERIES).toContain('@definition.function'); + expect(JAVASCRIPT_QUERIES).toContain('@definition.method'); + }); + + it('captures heritage (extends)', () => { + expect(JAVASCRIPT_QUERIES).toContain('@heritage.extends'); + }); + + it('does not have interface declarations', () => { + expect(JAVASCRIPT_QUERIES).not.toContain('interface_declaration'); + }); + }); + + describe('Python queries', () => { + it('captures class and function definitions', () => { + expect(PYTHON_QUERIES).toContain('class_definition'); + expect(PYTHON_QUERIES).toContain('function_definition'); + }); + + it('captures imports including from-imports', () => { + expect(PYTHON_QUERIES).toContain('import_statement'); + expect(PYTHON_QUERIES).toContain('import_from_statement'); + }); + + it('captures heritage (class inheritance)', () => { + expect(PYTHON_QUERIES).toContain('@heritage.extends'); + }); + }); + + describe('Java queries', () => { + it('captures all major declaration types', () => { + expect(JAVA_QUERIES).toContain('@definition.class'); + expect(JAVA_QUERIES).toContain('@definition.interface'); + expect(JAVA_QUERIES).toContain('@definition.enum'); + expect(JAVA_QUERIES).toContain('@definition.method'); + expect(JAVA_QUERIES).toContain('@definition.constructor'); + expect(JAVA_QUERIES).toContain('@definition.annotation'); + }); + + it('captures extends and implements heritage', () => { + expect(JAVA_QUERIES).toContain('@heritage.extends'); + expect(JAVA_QUERIES).toContain('@heritage.implements'); + }); + }); + + describe('C queries', () => { + it('captures function definitions', () => { + expect(C_QUERIES).toContain('function_definition'); + expect(C_QUERIES).toContain('@definition.function'); + }); + + it('captures struct, union, enum, typedef', () => { + expect(C_QUERIES).toContain('@definition.struct'); + expect(C_QUERIES).toContain('@definition.union'); + expect(C_QUERIES).toContain('@definition.enum'); + expect(C_QUERIES).toContain('@definition.typedef'); + }); + + it('captures macros', () => { + expect(C_QUERIES).toContain('@definition.macro'); + }); + + it('captures includes as imports', () => { + expect(C_QUERIES).toContain('preproc_include'); + }); + }); + + describe('Go queries', () => { + it('captures function and method declarations', () => { + expect(GO_QUERIES).toContain('function_declaration'); + expect(GO_QUERIES).toContain('method_declaration'); + }); + + it('captures struct and interface types', () => { + expect(GO_QUERIES).toContain('@definition.struct'); + expect(GO_QUERIES).toContain('@definition.interface'); + }); + + it('captures import declarations', () => { + expect(GO_QUERIES).toContain('import_declaration'); + }); + }); + + describe('C++ queries', () => { + it('captures class, struct, namespace', () => { + expect(CPP_QUERIES).toContain('@definition.class'); + expect(CPP_QUERIES).toContain('@definition.struct'); + expect(CPP_QUERIES).toContain('@definition.namespace'); + }); + + it('captures templates', () => { + expect(CPP_QUERIES).toContain('@definition.template'); + expect(CPP_QUERIES).toContain('template_declaration'); + }); + + it('captures heritage (base class)', () => { + expect(CPP_QUERIES).toContain('@heritage.extends'); + }); + }); + + describe('C# queries', () => { + it('captures all major types', () => { + expect(CSHARP_QUERIES).toContain('@definition.class'); + expect(CSHARP_QUERIES).toContain('@definition.interface'); + expect(CSHARP_QUERIES).toContain('@definition.struct'); + expect(CSHARP_QUERIES).toContain('@definition.enum'); + expect(CSHARP_QUERIES).toContain('@definition.record'); + expect(CSHARP_QUERIES).toContain('@definition.delegate'); + }); + + it('captures namespace declarations', () => { + expect(CSHARP_QUERIES).toContain('@definition.namespace'); + }); + + it('captures constructor and property', () => { + expect(CSHARP_QUERIES).toContain('@definition.constructor'); + expect(CSHARP_QUERIES).toContain('@definition.property'); + }); + }); + + describe('Rust queries', () => { + it('captures function items', () => { + expect(RUST_QUERIES).toContain('function_item'); + expect(RUST_QUERIES).toContain('@definition.function'); + }); + + it('captures struct, enum, trait, impl', () => { + expect(RUST_QUERIES).toContain('@definition.struct'); + expect(RUST_QUERIES).toContain('@definition.enum'); + expect(RUST_QUERIES).toContain('@definition.trait'); + expect(RUST_QUERIES).toContain('@definition.impl'); + }); + + it('captures module, const, static, macro', () => { + expect(RUST_QUERIES).toContain('@definition.module'); + expect(RUST_QUERIES).toContain('@definition.const'); + expect(RUST_QUERIES).toContain('@definition.static'); + expect(RUST_QUERIES).toContain('@definition.macro'); + }); + + it('captures trait implementation heritage', () => { + expect(RUST_QUERIES).toContain('@heritage.trait'); + expect(RUST_QUERIES).toContain('@heritage.class'); + }); + }); + + describe('PHP queries', () => { + it('captures class, interface, trait, enum', () => { + expect(PHP_QUERIES).toContain('@definition.class'); + expect(PHP_QUERIES).toContain('@definition.interface'); + expect(PHP_QUERIES).toContain('@definition.trait'); + expect(PHP_QUERIES).toContain('@definition.enum'); + }); + + it('captures top-level function definitions', () => { + expect(PHP_QUERIES).toContain('function_definition'); + expect(PHP_QUERIES).toContain('@definition.function'); + }); + + it('captures method declarations', () => { + expect(PHP_QUERIES).toContain('method_declaration'); + expect(PHP_QUERIES).toContain('@definition.method'); + }); + + it('captures class properties', () => { + expect(PHP_QUERIES).toContain('property_declaration'); + expect(PHP_QUERIES).toContain('@definition.property'); + }); + + it('captures heritage (extends, implements, use trait)', () => { + expect(PHP_QUERIES).toContain('@heritage.extends'); + expect(PHP_QUERIES).toContain('@heritage.implements'); + expect(PHP_QUERIES).toContain('@heritage.trait'); + }); + + it('captures namespace definitions', () => { + expect(PHP_QUERIES).toContain('namespace_definition'); + expect(PHP_QUERIES).toContain('@definition.namespace'); + }); + }); + + describe('Swift queries', () => { + it('captures class, struct, enum', () => { + expect(SWIFT_QUERIES).toContain('@definition.class'); + expect(SWIFT_QUERIES).toContain('@definition.struct'); + expect(SWIFT_QUERIES).toContain('@definition.enum'); + }); + + it('captures protocols as interfaces', () => { + expect(SWIFT_QUERIES).toContain('protocol_declaration'); + expect(SWIFT_QUERIES).toContain('@definition.interface'); + }); + + it('captures init declarations as constructors', () => { + expect(SWIFT_QUERIES).toContain('init_declaration'); + expect(SWIFT_QUERIES).toContain('@definition.constructor'); + }); + + it('captures function declarations', () => { + expect(SWIFT_QUERIES).toContain('function_declaration'); + expect(SWIFT_QUERIES).toContain('@definition.function'); + }); + + it('captures protocol method declarations', () => { + expect(SWIFT_QUERIES).toContain('protocol_function_declaration'); + expect(SWIFT_QUERIES).toContain('@definition.method'); + }); + + it('captures properties', () => { + expect(SWIFT_QUERIES).toContain('property_declaration'); + expect(SWIFT_QUERIES).toContain('@definition.property'); + }); + + it('captures heritage (inheritance)', () => { + expect(SWIFT_QUERIES).toContain('@heritage.extends'); + }); + + it('captures type aliases', () => { + expect(SWIFT_QUERIES).toContain('typealias_declaration'); + expect(SWIFT_QUERIES).toContain('@definition.type'); + }); + + it('captures extensions as classes', () => { + expect(SWIFT_QUERIES).toContain('"extension"'); + }); + + it('captures actors as classes', () => { + expect(SWIFT_QUERIES).toContain('"actor"'); + }); + }); +}); diff --git a/gitnexus/test/unit/type-env.test.ts b/gitnexus/test/unit/type-env.test.ts new file mode 100644 index 0000000000..fcbebaba26 --- /dev/null +++ b/gitnexus/test/unit/type-env.test.ts @@ -0,0 +1,3694 @@ +import { describe, it, expect } from 'vitest'; +import { buildTypeEnv, type TypeEnv, type TypeEnvironment } from '../../src/core/ingestion/type-env.js'; +import { stripNullable, extractSimpleTypeName } from '../../src/core/ingestion/type-extractors/shared.js'; +import Parser from 'tree-sitter'; +import TypeScript from 'tree-sitter-typescript'; +import Java from 'tree-sitter-java'; +import CSharp from 'tree-sitter-c-sharp'; +import Go from 'tree-sitter-go'; +import Rust from 'tree-sitter-rust'; +import Python from 'tree-sitter-python'; +import CPP from 'tree-sitter-cpp'; +import Kotlin from 'tree-sitter-kotlin'; +import PHP from 'tree-sitter-php'; +import Ruby from 'tree-sitter-ruby'; + +const parser = new Parser(); + +const parse = (code: string, lang: any) => { + parser.setLanguage(lang); + return parser.parse(code); +}; + +/** Flatten a scoped TypeEnv into a simple name→type map (for simple test assertions). */ +function flatGet(env: TypeEnv, varName: string): string | undefined { + for (const [, scopeMap] of env) { + const val = scopeMap.get(varName); + if (val) return val; + } + return undefined; +} + +/** Count all bindings across all scopes. */ +function flatSize(env: TypeEnv): number { + let count = 0; + for (const [, scopeMap] of env) count += scopeMap.size; + return count; +} + +describe('buildTypeEnv', () => { + describe('TypeScript', () => { + it('extracts type from const declaration', () => { + const tree = parse('const user: User = getUser();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from let declaration', () => { + const tree = parse('let repo: Repository;', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'repo')).toBe('Repository'); + }); + + it('extracts type from function parameters', () => { + const tree = parse('function save(user: User, repo: Repository) {}', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repository'); + }); + + it('extracts type from arrow function parameters', () => { + const tree = parse('const fn = (user: User) => user.save();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('ignores variables without type annotations', () => { + const tree = parse('const x = 5; let y = "hello";', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatSize(env)).toBe(0); + }); + + it('extracts type from nullable union User | null', () => { + const tree = parse('const user: User | null = getUser();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from optional union User | undefined', () => { + const tree = parse('let user: User | undefined;', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from triple nullable union User | null | undefined', () => { + const tree = parse('const user: User | null | undefined = getUser();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('ignores non-nullable unions like User | Repo', () => { + const tree = parse('const entity: User | Repo = getEntity();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'entity')).toBeUndefined(); + }); + }); + + describe('Java', () => { + it('extracts type from local variable declaration', () => { + const tree = parse(` + class App { + void run() { + User user = new User(); + Repository repo = getRepo(); + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repository'); + }); + + it('extracts type from method parameters', () => { + const tree = parse(` + class App { + void process(User user, Repository repo) {} + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repository'); + }); + + it('extracts type from field declaration', () => { + const tree = parse(` + class App { + private User user; + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('C#', () => { + it('extracts type from local variable declaration', () => { + const tree = parse(` + class App { + void Run() { + User user = new User(); + } + } + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from var with new expression', () => { + const tree = parse(` + class App { + void Run() { + var user = new User(); + } + } + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from method parameters', () => { + const tree = parse(` + class App { + void Process(User user, Repository repo) {} + } + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repository'); + }); + + it('extracts type from is pattern matching (obj is User user)', () => { + const tree = parse(` + class User { public void Save() {} } + class App { + void Process(object obj) { + if (obj is User user) { + user.Save(); + } + } + } + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('Go', () => { + it('extracts type from var declaration', () => { + const tree = parse(` + package main + func main() { + var user User + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from short var with composite literal', () => { + const tree = parse(` + package main + func main() { + user := User{Name: "Alice"} + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from address-of composite literal (&User{})', () => { + const tree = parse(` + package main + func main() { + user := &User{Name: "Alice"} + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from address-of in multi-assignment', () => { + const tree = parse(` + package main + func main() { + user, repo := &User{}, &Repo{} + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repo'); + }); + + it('infers type from new(User) built-in', () => { + const tree = parse(` + package main + func main() { + user := new(User) + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer from non-new function calls', () => { + const tree = parse(` + package main + func main() { + user := getUser() + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + + it('infers element type from make([]User, 0) slice builtin', () => { + const tree = parse(` + package main + func main() { + sl := make([]User, 0) + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'sl')).toBe('User'); + }); + + it('infers value type from make(map[string]User) map builtin', () => { + const tree = parse(` + package main + func main() { + m := make(map[string]User) + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'm')).toBe('User'); + }); + + it('infers type from type assertion: user := iface.(User)', () => { + const tree = parse(` + package main + type Saver interface { Save() } + func process(s Saver) { + user := s.(User) + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers type from type assertion in multi-assignment: user, ok := iface.(User)', () => { + const tree = parse(` + package main + type Saver interface { Save() } + func process(s Saver) { + user, ok := s.(User) + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from function parameters', () => { + const tree = parse(` + package main + func process(user User, repo Repository) {} + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + // Go parameter extraction depends on tree-sitter grammar structure + // Parameters may or may not have 'name'/'type' fields + }); + }); + + describe('Rust', () => { + it('extracts type from let declaration', () => { + const tree = parse(` + fn main() { + let user: User = User::new(); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from function parameters', () => { + const tree = parse(` + fn process(user: User, repo: Repository) {} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repository'); + }); + + it('extracts type from let with reference', () => { + const tree = parse(` + fn main() { + let user: &User = &get_user(); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('Python', () => { + it('extracts type from annotated assignment (PEP 484)', () => { + const tree = parse('user: User = get_user()', Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from standalone annotation without value (file scope)', () => { + const tree = parse('active_user: User', Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'active_user')).toBe('User'); + }); + + it('extracts type from function parameters', () => { + const tree = parse('def process(user: User, repo: Repository): pass', Python); + const { env } = buildTypeEnv(tree, 'python'); + // Python uses typed_parameter nodes, check if they match + }); + + it('extracts type from class-level annotation with default value', () => { + const tree = parse(`class User: + name: str = "default" + age: int = 0 +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'name')).toBe('str'); + expect(flatGet(env, 'age')).toBe('int'); + }); + + it('extracts type from class-level annotation without default value', () => { + const tree = parse(`class User: + repo: UserRepo +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'repo')).toBe('UserRepo'); + }); + + it('extracts types from mixed class-level annotations and methods', () => { + const tree = parse(`class User: + name: str = "default" + age: int = 0 + repo: UserRepo + + def save(self): + pass +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'name')).toBe('str'); + expect(flatGet(env, 'age')).toBe('int'); + expect(flatGet(env, 'repo')).toBe('UserRepo'); + }); + + describe('Python match/case as_pattern binding (Phase 6)', () => { + it('extracts type from `case User() as u` in match statement', () => { + const tree = parse(` +class User: + def save(self): + pass + +def process(x): + match x: + case User() as u: + u.save() +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'u')).toBe('User'); + }); + + it('does NOT overwrite an existing binding in scopeEnv', () => { + const tree = parse(` +class User: + pass + +def process(x): + u: User = x + match x: + case User() as u: + u.save() +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + // u is already bound from the annotation, pattern binding should not overwrite + expect(flatGet(env, 'u')).toBe('User'); + }); + + it('extracts type for each bound variable when multiple cases have as-patterns', () => { + const tree = parse(` +class User: + pass + +class Repo: + pass + +def process(x): + match x: + case User() as u: + u.save() + case Repo() as r: + r.save() +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'r')).toBe('Repo'); + }); + + it('does NOT extract binding when the pattern is not a class_pattern', () => { + // `case 42 as n:` — integer pattern, not a class_pattern + const tree = parse(` +def process(x): + match x: + case 42 as n: + pass +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + // No class_pattern child — should return undefined + expect(flatGet(env, 'n')).toBeUndefined(); + }); + }); + }); + + describe('C++', () => { + it('extracts type from local variable declaration', () => { + const tree = parse(` + void run() { + User user; + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from initialized declaration', () => { + const tree = parse(` + void run() { + User user = getUser(); + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from pointer declaration', () => { + const tree = parse(` + void run() { + User* user = new User(); + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from function parameters', () => { + const tree = parse(` + void process(User user, Repository& repo) {} + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repository'); + }); + + it('extracts type from range-for with explicit type', () => { + const tree = parse(` + void run() { + std::vector<User> users; + for (User& user : users) { + user.save(); + } + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from range-for with const ref', () => { + const tree = parse(` + void run() { + std::vector<User> users; + for (const User& user : users) { + user.save(); + } + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('PHP', () => { + it('extracts type from function parameters', () => { + const tree = parse(`<?php + function process(User $user, Repository $repo) {} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + // PHP parameter type extraction + expect(flatGet(env, '$user')).toBe('User'); + expect(flatGet(env, '$repo')).toBe('Repository'); + }); + + it('resolves $this to enclosing class name', () => { + const code = `<?php +class UserService { + public function process(): void { + $this->save(); + } +}`; + const tree = parse(code, PHP.php); + const typeEnv = buildTypeEnv(tree, 'php'); + + // Find the call node ($this->save()) + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'member_call_expression') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + expect(calls.length).toBe(1); + // $this should resolve to enclosing class 'UserService' + expect(typeEnv.lookup('$this', calls[0])).toBe('UserService'); + }); + + it('extracts type from constructor property promotion (PHP 8.0+)', () => { + const tree = parse(`<?php +class User { + public function __construct( + private string $name, + private UserRepo $repo + ) {} +} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$repo')).toBe('UserRepo'); + }); + + it('extracts type from typed class property (PHP 7.4+)', () => { + const tree = parse(`<?php +class UserService { + private UserRepo $repo; +} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$repo')).toBe('UserRepo'); + }); + + it('extracts type from typed class property with default value', () => { + const tree = parse(`<?php +class UserService { + public string $name = "test"; +} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$name')).toBe('string'); + }); + + it('extracts PHPDoc @param with standard order: @param Type $name', () => { + const tree = parse(`<?php +/** + * @param UserRepo $repo the repository + * @param string $name the user name + */ +function create($repo, $name) { + $repo->save(); +} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$repo')).toBe('UserRepo'); + expect(flatGet(env, '$name')).toBe('string'); + }); + + it('extracts PHPDoc @param with alternate order: @param $name Type', () => { + const tree = parse(`<?php +/** + * @param $repo UserRepo the repository + * @param $name string the user name + */ +function process($repo, $name) { + $repo->save(); +} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$repo')).toBe('UserRepo'); + expect(flatGet(env, '$name')).toBe('string'); + }); + }); + + describe('Ruby YARD annotations', () => { + it('extracts @param type bindings from YARD comments', () => { + const tree = parse(` +class UserService + # @param repo [UserRepo] the repository + # @param name [String] the user's name + def create(repo, name) + repo.save + end +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + expect(flatGet(env, 'repo')).toBe('UserRepo'); + expect(flatGet(env, 'name')).toBe('String'); + }); + + it('handles qualified YARD types (Models::User → User)', () => { + const tree = parse(` +# @param user [Models::User] the user +def process(user) +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('handles nullable YARD types (String, nil → String)', () => { + const tree = parse(` +# @param name [String, nil] optional name +def greet(name) +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + expect(flatGet(env, 'name')).toBe('String'); + }); + + it('skips ambiguous union YARD types (String, Integer → undefined)', () => { + const tree = parse(` +# @param value [String, Integer] mixed type +def process(value) +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + expect(flatGet(env, 'value')).toBeUndefined(); + }); + + it('extracts no types when no YARD comments present', () => { + const tree = parse(` +def create(repo, name) + repo.save +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + expect(flatSize(env)).toBe(0); + }); + + it('extracts types from singleton method YARD comments', () => { + const tree = parse(` +class UserService + # @param name [String] the user's name + def self.find(name) + name + end +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + expect(flatGet(env, 'name')).toBe('String'); + }); + + it('handles generic YARD types (Array<User> → Array)', () => { + const tree = parse(` +# @param users [Array<User>] list of users +def process(users) +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + expect(flatGet(env, 'users')).toBe('Array'); + }); + }); + + describe('super/base/parent resolution', () => { + it('resolves super to parent class name (TypeScript)', () => { + const code = ` +class BaseModel { + save(): boolean { return true; } +} +class User extends BaseModel { + save(): boolean { + super.save(); + return true; + } +}`; + const tree = parse(code, TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'call_expression') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + // Find the super.save() call (inside User class) + const superCall = calls.find((c: any) => { + const text = c.text; + return text.includes('super'); + }); + expect(superCall).toBeDefined(); + expect(typeEnv.lookup('super', superCall)).toBe('BaseModel'); + }); + + it('resolves super to parent class name (Java)', () => { + const code = ` +class BaseModel { + boolean save() { return true; } +} +class User extends BaseModel { + boolean save() { + super.save(); + return true; + } +}`; + const tree = parse(code, Java); + const typeEnv = buildTypeEnv(tree, 'java'); + + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'method_invocation') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + const superCall = calls.find((c: any) => c.text.includes('super')); + expect(superCall).toBeDefined(); + expect(typeEnv.lookup('super', superCall)).toBe('BaseModel'); + }); + + it('resolves super to parent class name (Python)', () => { + const code = ` +class BaseModel: + def save(self) -> bool: + return True + +class User(BaseModel): + def save(self) -> bool: + super().save() + return True +`; + const tree = parse(code, Python); + const typeEnv = buildTypeEnv(tree, 'python'); + + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'call') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + // Find a call inside the User class + const superCall = calls.find((c: any) => c.text.includes('super')); + expect(superCall).toBeDefined(); + expect(typeEnv.lookup('super', superCall)).toBe('BaseModel'); + }); + + it('returns undefined when class has no parent', () => { + const code = ` +class Standalone { + save(): boolean { + return true; + } +}`; + const tree = parse(code, TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + + // No calls in this code — test the resolution function directly + // by using the class body as the context node + const classNode = tree.rootNode.firstNamedChild; + expect(typeEnv.lookup('super', classNode!)).toBeUndefined(); + }); + }); + + describe('Kotlin object_declaration this resolution', () => { + it('resolves this inside object declaration', () => { + const code = ` +object AppConfig { + fun setup() { + this.init() + } +}`; + const tree = parse(code, Kotlin); + const typeEnv = buildTypeEnv(tree, 'kotlin'); + + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'call_expression') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + expect(calls.length).toBe(1); + expect(typeEnv.lookup('this', calls[0])).toBe('AppConfig'); + }); + }); + + describe('scope awareness', () => { + it('separates same-named variables in different functions', () => { + const tree = parse(` + function handleUser(user: User) { + user.save(); + } + function handleRepo(user: Repo) { + user.save(); + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + + // Each function has its own scope for 'user' (keyed by funcName@startIndex) + // Find the scope keys that start with handleUser/handleRepo + const scopes = [...env.keys()]; + const handleUserKey = scopes.find(k => k.startsWith('handleUser@')); + const handleRepoKey = scopes.find(k => k.startsWith('handleRepo@')); + expect(handleUserKey).toBeDefined(); + expect(handleRepoKey).toBeDefined(); + expect(env.get(handleUserKey!)?.get('user')).toBe('User'); + expect(env.get(handleRepoKey!)?.get('user')).toBe('Repo'); + }); + + it('lookup resolves from enclosing function scope', () => { + const code = ` +function handleUser(user: User) { + user.save(); +} +function handleRepo(user: Repo) { + user.save(); +}`; + const tree = parse(code, TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + + // Find the call nodes inside each function + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'call_expression') calls.push(node); + for (let i = 0; i < node.childCount; i++) { + findCalls(node.child(i)); + } + } + findCalls(tree.rootNode); + + expect(calls.length).toBe(2); + // First call is inside handleUser → user should be User + expect(typeEnv.lookup('user', calls[0])).toBe('User'); + // Second call is inside handleRepo → user should be Repo + expect(typeEnv.lookup('user', calls[1])).toBe('Repo'); + }); + + it('separates same-named methods in different classes via startIndex', () => { + const code = ` +class UserService { + process(user: User) { + user.save(); + } +} +class RepoService { + process(repo: Repo) { + repo.save(); + } +}`; + const tree = parse(code, TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + + // Find the call nodes inside each process method + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'call_expression') calls.push(node); + for (let i = 0; i < node.childCount; i++) { + findCalls(node.child(i)); + } + } + findCalls(tree.rootNode); + + expect(calls.length).toBe(2); + // First call inside UserService.process → user should be User + expect(typeEnv.lookup('user', calls[0])).toBe('User'); + // Second call inside RepoService.process → repo should be Repo + expect(typeEnv.lookup('repo', calls[1])).toBe('Repo'); + }); + + it('file-level variables are accessible from all scopes', () => { + const tree = parse(` + const config: Config = getConfig(); + function process(user: User) { + config.validate(); + user.save(); + } + `, TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + + // config is at file-level scope + const fileScope = typeEnv.env.get(''); + expect(fileScope?.get('config')).toBe('Config'); + + // user is in process scope (key includes startIndex) + // Find call nodes inside the process function + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'call_expression') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + // calls[0] = getConfig() at file level, calls[1] = config.validate(), calls[2] = user.save() + expect(typeEnv.lookup('user', calls[2])).toBe('User'); + // config is file-level, accessible from any scope + expect(typeEnv.lookup('config', calls[1])).toBe('Config'); + }); + }); + + describe('destructuring patterns (known limitations)', () => { + it('captures the typed source variable but not destructured bindings', () => { + const tree = parse(` + const user: User = getUser(); + const { name, email } = user; + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // The typed variable is captured + expect(flatGet(env, 'user')).toBe('User'); + // Destructured bindings (name, email) would need type inference to resolve + // — not extractable from annotations alone + expect(flatGet(env, 'name')).toBeUndefined(); + expect(flatGet(env, 'email')).toBeUndefined(); + }); + + it('does not extract from object-type-annotated destructuring', () => { + // TypeScript allows: const { name }: { name: string } = user; + // The annotation is on the whole pattern, not individual bindings + const tree = parse(` + const { name }: { name: string } = getUser(); + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // Complex type annotation (object type) — extractSimpleTypeName returns undefined + expect(flatSize(env)).toBe(0); + }); + }); + + describe('constructor inference (Tier 1 fallback)', () => { + describe('TypeScript', () => { + it('infers type from new expression when no annotation', () => { + const tree = parse('const user = new User();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('prefers explicit annotation over constructor inference', () => { + const tree = parse('const user: BaseUser = new User();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('BaseUser'); + }); + + it('infers from namespaced constructor: new ns.Service()', () => { + // extractSimpleTypeName handles member_expression via property_identifier + const tree = parse('const svc = new ns.Service();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'svc')).toBe('Service'); + }); + + it('infers type from new expression with as cast', () => { + const tree = parse('const x = new User() as BaseUser;', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // Unwraps as_expression to find the inner new_expression → User + expect(flatGet(env, 'x')).toBe('User'); + }); + + it('infers type from new expression with non-null assertion', () => { + const tree = parse('const x = new User()!;', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // Unwraps non_null_expression to find the inner new_expression → User + expect(flatGet(env, 'x')).toBe('User'); + }); + + it('infers type from double-cast (new X() as unknown as T)', () => { + const tree = parse('const x = new User() as unknown as Admin;', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // Unwraps nested as_expression to find inner new_expression → User + expect(flatGet(env, 'x')).toBe('User'); + }); + + it('ignores non-new assignments', () => { + const tree = parse('const x = getUser();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatSize(env)).toBe(0); + }); + + it('handles mixed annotated + unannotated declarators', () => { + const tree = parse('const a: A = getA(), b = new B();', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'a')).toBe('A'); + expect(flatGet(env, 'b')).toBe('B'); + }); + }); + + describe('Java', () => { + it('infers type from var with new expression (Java 10+)', () => { + const tree = parse(` + class App { + void run() { + var user = new User(); + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('prefers explicit type over constructor inference', () => { + const tree = parse(` + class App { + void run() { + User user = new User(); + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer from var without new expression', () => { + const tree = parse(` + class App { + void run() { + var x = getUser(); + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'x')).toBeUndefined(); + }); + }); + + describe('Rust', () => { + it('infers type from Type::new()', () => { + const tree = parse(` + fn main() { + let user = User::new(); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers type from Type::default()', () => { + const tree = parse(` + fn main() { + let config = Config::default(); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'config')).toBe('Config'); + }); + + it('does NOT emit scanner binding for Type::default() (handled by extractInitializer)', () => { + const tree = parse(` + fn main() { + let config = Config::default(); + } + `, Rust); + const { constructorBindings } = buildTypeEnv(tree, 'rust'); + // ::default() should be excluded from scanConstructorBinding just like ::new() + // extractInitializer already resolves it, so a scanner binding would be redundant + const defaultBinding = constructorBindings.find(b => b.calleeName === 'default'); + expect(defaultBinding).toBeUndefined(); + }); + + it('does NOT emit scanner binding for Type::new() (handled by extractInitializer)', () => { + const tree = parse(` + fn main() { + let user = User::new(); + } + `, Rust); + const { constructorBindings } = buildTypeEnv(tree, 'rust'); + const newBinding = constructorBindings.find(b => b.calleeName === 'new'); + expect(newBinding).toBeUndefined(); + }); + + it('prefers explicit annotation over constructor inference', () => { + // Uses DIFFERENT types to catch Tier 0 overwrite bugs + const tree = parse(` + fn main() { + let user: BaseUser = Admin::new(); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('BaseUser'); + }); + + it('infers type from let mut with ::new()', () => { + const tree = parse(` + fn main() { + let mut user = User::new(); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('resolves Self::new() to enclosing impl type', () => { + const tree = parse(` + struct User {} + impl User { + fn create() -> Self { + let instance = Self::new(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'instance')).toBe('User'); + }); + + it('resolves Self::default() to enclosing impl type', () => { + const tree = parse(` + struct Config {} + impl Config { + fn make() -> Self { + let cfg = Self::default(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'cfg')).toBe('Config'); + }); + + it('skips Self::new() outside impl block', () => { + const tree = parse(` + fn main() { + let x = Self::new(); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'x')).toBeUndefined(); + }); + + it('does not infer from Type::other_method()', () => { + const tree = parse(` + fn main() { + let user = User::from_str("alice"); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + + it('infers type from struct literal (User { ... })', () => { + const tree = parse(` + fn main() { + let user = User { name: "alice", age: 30 }; + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers type from empty struct literal (Config {})', () => { + const tree = parse(` + fn main() { + let config = Config {}; + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'config')).toBe('Config'); + }); + + it('prefers explicit annotation over struct literal inference', () => { + const tree = parse(` + fn main() { + let user: BaseUser = Admin { name: "alice" }; + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('BaseUser'); + }); + + it('resolves Self {} struct literal to enclosing impl type', () => { + const tree = parse(` + struct User { name: String } + impl User { + fn reset(&self) -> Self { + let fresh = Self { name: String::new() }; + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'fresh')).toBe('User'); + }); + + it('skips Self {} outside impl block', () => { + const tree = parse(` + fn main() { + let x = Self { name: String::new() }; + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'x')).toBeUndefined(); + }); + }); + + describe('Rust if-let / while-let pattern bindings', () => { + it('extracts type from captured_pattern in if let (user @ User { .. })', () => { + const tree = parse(` + fn process() { + if let user @ User { .. } = get_user() { + user.save(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from nested captured_pattern in if let Some(user @ User { .. })', () => { + const tree = parse(` + fn process(opt: Option<User>) { + if let Some(user @ User { .. }) = opt { + user.save(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('extracts type from captured_pattern in while let', () => { + const tree = parse(` + fn process() { + while let item @ Config { .. } = iter.next() { + item.validate(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'item')).toBe('Config'); + }); + + it('extracts binding from if let Some(x) = opt via Phase 5.2 pattern binding', () => { + const tree = parse(` + fn process(opt: Option<User>) { + if let Some(user) = opt { + user.save(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + // Option<User> is unwrapped to "User" in TypeEnv via NULLABLE_WRAPPER_TYPES. + // extractPatternBinding maps `user` → "User" from the scopeEnv lookup for `opt`. + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does NOT extract field bindings from struct pattern destructuring', () => { + const tree = parse(` + fn process(val: User) { + if let User { name } = val { + name.len(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + // 'name' is a field of User — we don't know its type without field-type resolution + expect(flatGet(env, 'name')).toBeUndefined(); + // 'val' should still be extracted from the parameter annotation + expect(flatGet(env, 'val')).toBe('User'); + }); + + it('extracts type from scoped struct pattern (Message::Data)', () => { + const tree = parse(` + fn process() { + if let msg @ Message::Data { .. } = get_msg() { + msg.process(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + // scoped_type_identifier: Message::Data — extractSimpleTypeName returns "Data" + expect(flatGet(env, 'msg')).toBe('Data'); + }); + + it('still extracts parameter types alongside if-let bindings', () => { + const tree = parse(` + fn process(opt: Option<User>) { + if let user @ User { .. } = get_user() { + user.save(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + // Option<User> unwraps to User (nullable wrapper unwrapping) + expect(flatGet(env, 'opt')).toBe('User'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('Phase 5.2: extracts binding from if let Some(x) = opt where opt: Option<User>', () => { + const tree = parse(` + fn process(opt: Option<User>) { + if let Some(user) = opt { + user.save(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + // opt: Option<User> → scopeEnv stores "User" (NULLABLE_WRAPPER_TYPES unwrapping) + // extractPatternBinding maps user → opt's type → "User" + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('Phase 5.2: does NOT extract binding when source variable is unknown', () => { + const tree = parse(` + fn process() { + if let Some(x) = unknown_var { + x.foo(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + // unknown_var is not in scopeEnv — conservative, produces no binding + expect(flatGet(env, 'x')).toBeUndefined(); + }); + + it('Phase 5.2: does NOT extract binding for non-Option/Result wrappers', () => { + const tree = parse(` + fn process(vec: Vec<User>) { + if let SomeOtherVariant(x) = vec { + x.save(); + } + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + // SomeOtherVariant is not a known unwrap wrapper — no binding + expect(flatGet(env, 'x')).toBeUndefined(); + }); + }); + + describe('Java instanceof pattern variable (Phase 5.2)', () => { + it('extracts binding from x instanceof User user', () => { + const tree = parse(` + class App { + void process(Object obj) { + if (obj instanceof User user) { + user.save(); + } + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does NOT extract binding from plain instanceof without variable', () => { + const tree = parse(` + class App { + void process(Object obj) { + boolean b = obj instanceof User; + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + // No pattern variable declared — no binding + expect(flatGet(env, 'b')).toBeUndefined(); + }); + + it('extracts correct type when multiple instanceof patterns exist', () => { + const tree = parse(` + class App { + void process(Object obj) { + if (obj instanceof User user) { + user.save(); + } + if (obj instanceof Repo repo) { + repo.save(); + } + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repo'); + }); + }); + + describe('PHP', () => { + it('infers type from new expression', () => { + const tree = parse(`<?php + $user = new User(); + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$user')).toBe('User'); + }); + + it('resolves new self() and new static() to enclosing class', () => { + const tree = parse(`<?php + class Foo { + function make() { + $a = new self(); + $b = new static(); + } + } + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$a')).toBe('Foo'); + expect(flatGet(env, '$b')).toBe('Foo'); + }); + + it('resolves new parent() to superclass', () => { + const tree = parse(`<?php + class Bar {} + class Foo extends Bar { + function make() { + $p = new parent(); + } + } + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$p')).toBe('Bar'); + }); + + it('skips self/static/parent outside class scope', () => { + const tree = parse(`<?php + $a = new self(); + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$a')).toBeUndefined(); + }); + + it('does not infer from non-new assignments', () => { + const tree = parse(`<?php + $user = getUser(); + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$user')).toBeUndefined(); + }); + }); + + describe('C++', () => { + it('infers type from auto with new expression', () => { + const tree = parse(` + void run() { + auto user = new User(); + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers type from auto with direct construction when class is defined', () => { + const tree = parse(` + class User {}; + void run() { + auto user = User(); + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('prefers explicit type over auto inference', () => { + const tree = parse(` + void run() { + User* user = new User(); + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer from auto with function call (not a known class)', () => { + const tree = parse(` + class User {}; + User getUser() { return User(); } + void run() { + auto x = getUser(); + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + // getUser is an identifier but NOT a known class — no inference + expect(flatGet(env, 'x')).toBeUndefined(); + }); + + it('infers type from brace initialization (User{})', () => { + const tree = parse(` + class User {}; + void run() { + auto user = User{}; + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers type from brace initialization with args (User{1,2})', () => { + const tree = parse(` + class Config {}; + void run() { + auto cfg = Config{1, 2}; + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'cfg')).toBe('Config'); + }); + + it('infers type from namespaced brace-init (ns::User{})', () => { + const tree = parse(` + namespace ns { class User {}; } + void run() { + auto user = ns::User{}; + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('Kotlin constructor inference', () => { + it('still extracts explicit type annotations', () => { + const tree = parse(` + fun main() { + val user: User = User() + } + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers type from constructor call when class is in same file', () => { + const tree = parse(` + class User(val name: String) + fun main() { + val user = User("Alice") + } + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does NOT infer type from plain function call', () => { + const tree = parse(` + fun getUser(): User = User("Alice") + fun main() { + val user = getUser() + } + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + // getUser is not a class name — should NOT produce a binding + expect(flatGet(env, 'user')).toBeUndefined(); + }); + + it('infers type from constructor when class defined via SymbolTable', () => { + const tree = parse(` + fun main() { + val user = User("Alice") + } + `, Kotlin); + // User is NOT defined in this file, but SymbolTable knows it's a Class + const mockSymbolTable = { + lookupFuzzy: (name: string) => + name === 'User' ? [{ nodeId: 'n1', filePath: 'models.kt', type: 'Class' }] : [], + lookupExact: () => undefined, + lookupExactFull: () => undefined, + add: () => {}, + getStats: () => ({ fileCount: 0, globalSymbolCount: 0 }), + clear: () => {}, + }; + const { env } = buildTypeEnv(tree, 'kotlin', mockSymbolTable as any); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does NOT infer when SymbolTable says callee is a Function', () => { + const tree = parse(` + fun main() { + val result = doStuff() + } + `, Kotlin); + const mockSymbolTable = { + lookupFuzzy: (name: string) => + name === 'doStuff' ? [{ nodeId: 'n1', filePath: 'utils.kt', type: 'Function' }] : [], + lookupExact: () => undefined, + lookupExactFull: () => undefined, + add: () => {}, + getStats: () => ({ fileCount: 0, globalSymbolCount: 0 }), + clear: () => {}, + }; + const { env } = buildTypeEnv(tree, 'kotlin', mockSymbolTable as any); + expect(flatGet(env, 'result')).toBeUndefined(); + }); + + it('prefers explicit annotation over constructor inference', () => { + const tree = parse(` + class User(val name: String) + fun main() { + val user: BaseEntity = User("Alice") + } + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + // Tier 0 (explicit annotation) wins over Tier 1 (constructor inference) + expect(flatGet(env, 'user')).toBe('BaseEntity'); + }); + }); + + describe('Python constructor inference', () => { + it('infers type from direct constructor call when class is known', () => { + const tree = parse(` +class User: + pass + +def main(): + user = User("alice") +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers type from qualified constructor call (models.User)', () => { + const tree = parse(` +class User: + pass + +def main(): + user = models.User("alice") +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + // extractSimpleTypeName extracts "User" from attribute node "models.User" + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer from plain function call', () => { + const tree = parse(` +def main(): + user = get_user() +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + }); + + describe('Python walrus operator type inference', () => { + it('infers type from walrus operator with constructor call', () => { + const tree = parse(` +class User: + pass + +def main(): + if (user := User("alice")): + pass +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer type from walrus operator without known class', () => { + const tree = parse(` +def main(): + if (data := get_data()): + pass +`, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'data')).toBeUndefined(); + }); + }); + }); + + describe('edge cases', () => { + it('returns empty map for code without type annotations', () => { + const tree = parse('const x = 5;', TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatSize(env)).toBe(0); + }); + + it('last-write-wins for same variable name in same scope', () => { + const tree = parse(` + let x: User = getUser(); + let x: Admin = getAdmin(); + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // Both declarations are at file level; last one wins + expect(flatGet(env, 'x')).toBeDefined(); + }); + }); + + describe('generic parent class resolution', () => { + it('resolves super through generic parent (TypeScript)', () => { + const code = ` +class BaseModel<T> { + save(): T { return {} as T; } +} +class User extends BaseModel<string> { + save(): string { + super.save(); + return "ok"; + } +}`; + const tree = parse(code, TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'call_expression') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + const superCall = calls.find((c: any) => c.text.includes('super')); + expect(superCall).toBeDefined(); + // Should resolve to "BaseModel", not "BaseModel<string>" + expect(typeEnv.lookup('super', superCall)).toBe('BaseModel'); + }); + + it('resolves super through generic parent (Java)', () => { + const code = ` +class BaseModel<T> { + T save() { return null; } +} +class User extends BaseModel<String> { + String save() { + super.save(); + return "ok"; + } +}`; + const tree = parse(code, Java); + const typeEnv = buildTypeEnv(tree, 'java'); + + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'method_invocation') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + const superCall = calls.find((c: any) => c.text.includes('super')); + expect(superCall).toBeDefined(); + // Should resolve to "BaseModel", not "BaseModel<String>" + expect(typeEnv.lookup('super', superCall)).toBe('BaseModel'); + }); + + it('resolves super through qualified parent (Python models.Model)', () => { + const code = ` +class Model: + def save(self): + pass + +class User(Model): + def save(self): + super().save() +`; + const tree = parse(code, Python); + const typeEnv = buildTypeEnv(tree, 'python'); + + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'call') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + const superCall = calls.find((c: any) => c.text.includes('super')); + expect(superCall).toBeDefined(); + expect(typeEnv.lookup('super', superCall)).toBe('Model'); + }); + + it('resolves super through generic parent (C#)', () => { + const code = ` +class BaseModel<T> { + public T Save() { return default; } +} +class User : BaseModel<string> { + public string Save() { + base.Save(); + return "ok"; + } +}`; + const tree = parse(code, CSharp); + const typeEnv = buildTypeEnv(tree, 'csharp'); + + const calls: any[] = []; + function findCalls(node: any) { + if (node.type === 'invocation_expression') calls.push(node); + for (let i = 0; i < node.childCount; i++) findCalls(node.child(i)); + } + findCalls(tree.rootNode); + + const baseCall = calls.find((c: any) => c.text.includes('base')); + expect(baseCall).toBeDefined(); + // Should resolve to "BaseModel", not "BaseModel<string>" + expect(typeEnv.lookup('base', baseCall)).toBe('BaseModel'); + }); + }); + + describe('C++ namespaced constructor binding', () => { + it('infers type from auto with namespaced constructor (ns::User)', () => { + const tree = parse(` + namespace ns { + class HttpClient {}; + } + void run() { + auto client = ns::HttpClient(); + } + `, CPP); + const { constructorBindings } = buildTypeEnv(tree, 'cpp'); + // Should extract "HttpClient" from the scoped_identifier ns::HttpClient + const binding = constructorBindings.find(b => b.varName === 'client'); + expect(binding).toBeDefined(); + expect(binding!.calleeName).toBe('HttpClient'); + }); + + it('does not extract from non-namespaced plain identifier (existing behavior)', () => { + const tree = parse(` + class User {}; + void run() { + auto user = User(); + } + `, CPP); + const { env, constructorBindings } = buildTypeEnv(tree, 'cpp'); + // User() with known class resolves via extractInitializer, not constructor bindings + expect(flatGet(env, 'user')).toBe('User'); + // No unresolved bindings since User is locally known + expect(constructorBindings.find(b => b.varName === 'user')).toBeUndefined(); + }); + }); + + describe('constructorBindings merged into buildTypeEnv', () => { + it('returns constructor bindings for Kotlin val x = UnknownClass()', () => { + const tree = parse(` + fun main() { + val user = UnknownClass() + } + `, Kotlin); + const { env, constructorBindings } = buildTypeEnv(tree, 'kotlin'); + // UnknownClass is not defined locally — should appear as unverified binding + expect(flatGet(env, 'user')).toBeUndefined(); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('user'); + expect(constructorBindings[0].calleeName).toBe('UnknownClass'); + }); + + it('does NOT emit constructor binding when TypeEnv already resolved', () => { + const tree = parse(` + fun main() { + val user: User = User() + } + `, Kotlin); + const { env, constructorBindings } = buildTypeEnv(tree, 'kotlin'); + // Explicit annotation resolves it — no unverified binding needed + expect(flatGet(env, 'user')).toBe('User'); + expect(constructorBindings.find(b => b.varName === 'user')).toBeUndefined(); + }); + + it('returns constructor bindings for Python x = UnknownClass()', () => { + const tree = parse(` +def main(): + user = SomeClass() +`, Python); + const { env, constructorBindings } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBeUndefined(); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('user'); + expect(constructorBindings[0].calleeName).toBe('SomeClass'); + }); + + it('returns constructor bindings for Python qualified call (models.User)', () => { + const tree = parse(` +def main(): + user = models.User("alice") +`, Python); + const { constructorBindings } = buildTypeEnv(tree, 'python'); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('user'); + expect(constructorBindings[0].calleeName).toBe('User'); + }); + + it('returns constructor bindings for Python walrus operator (user := SomeClass())', () => { + const tree = parse(` +def main(): + if (user := SomeClass()): + pass +`, Python); + const { env, constructorBindings } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBeUndefined(); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('user'); + expect(constructorBindings[0].calleeName).toBe('SomeClass'); + }); + + it('returns empty bindings for language without scanner (Go)', () => { + const tree = parse(` + package main + func main() { + var x int = 5 + } + `, Go); + const { constructorBindings } = buildTypeEnv(tree, 'go'); + expect(constructorBindings).toEqual([]); + }); + + it('returns constructor bindings for Ruby constant assignment (REPO = Repo.new)', () => { + const tree = parse(` +REPO = Repo.new +`, Ruby); + const { constructorBindings } = buildTypeEnv(tree, 'ruby'); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('REPO'); + expect(constructorBindings[0].calleeName).toBe('Repo'); + }); + + it('returns constructor bindings for Ruby namespaced constructor (service = Models::UserService.new)', () => { + const tree = parse(` +service = Models::UserService.new +`, Ruby); + const { constructorBindings } = buildTypeEnv(tree, 'ruby'); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('service'); + expect(constructorBindings[0].calleeName).toBe('UserService'); + }); + + it('returns constructor bindings for deeply namespaced Ruby constructor (svc = App::Models::Service.new)', () => { + const tree = parse(` +svc = App::Models::Service.new +`, Ruby); + const { constructorBindings } = buildTypeEnv(tree, 'ruby'); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('svc'); + expect(constructorBindings[0].calleeName).toBe('Service'); + }); + + it('includes scope key in constructor bindings', () => { + const tree = parse(` + fun process() { + val user = RemoteUser() + } + `, Kotlin); + const { constructorBindings } = buildTypeEnv(tree, 'kotlin'); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].scope).toMatch(/^process@\d+$/); + }); + + it('returns constructor bindings for TypeScript const user = getUser()', () => { + const tree = parse('const user = getUser();', TypeScript.typescript); + const { env, constructorBindings } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBeUndefined(); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('user'); + expect(constructorBindings[0].calleeName).toBe('getUser'); + }); + + it('does NOT emit constructor binding when TypeScript var has explicit type annotation', () => { + const tree = parse('const user: User = getUser();', TypeScript.typescript); + const { env, constructorBindings } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + expect(constructorBindings.find(b => b.varName === 'user')).toBeUndefined(); + }); + + it('skips destructuring patterns (array_pattern) for TypeScript', () => { + const tree = parse('const [a, b] = getPair();', TypeScript.typescript); + const { constructorBindings } = buildTypeEnv(tree, 'typescript'); + expect(constructorBindings).toEqual([]); + }); + + it('skips destructuring patterns (object_pattern) for TypeScript', () => { + const tree = parse('const { name, age } = getUser();', TypeScript.typescript); + const { constructorBindings } = buildTypeEnv(tree, 'typescript'); + expect(constructorBindings).toEqual([]); + }); + + it('unwraps await in TypeScript: const user = await fetchUser()', () => { + const tree = parse('async function f() { const user = await fetchUser(); }', TypeScript.typescript); + const { constructorBindings } = buildTypeEnv(tree, 'typescript'); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('user'); + expect(constructorBindings[0].calleeName).toBe('fetchUser'); + }); + + it('handles qualified callee in TypeScript: const user = repo.getUser()', () => { + const tree = parse('const user = repo.getUser();', TypeScript.typescript); + const { constructorBindings } = buildTypeEnv(tree, 'typescript'); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('user'); + expect(constructorBindings[0].calleeName).toBe('getUser'); + }); + + it('does not emit binding for TypeScript new expression (handled by extractInitializer)', () => { + const tree = parse('const user = new User();', TypeScript.typescript); + const { env, constructorBindings } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + expect(constructorBindings.find(b => b.varName === 'user')).toBeUndefined(); + }); + + it('returns constructor binding for C# var user = svc.GetUser()', () => { + const tree = parse(` + class App { + void Run() { + var svc = new UserService(); + var user = svc.GetUser("alice"); + } + } + `, CSharp); + const { constructorBindings } = buildTypeEnv(tree, 'csharp'); + const binding = constructorBindings.find(b => b.varName === 'user'); + expect(binding).toBeDefined(); + expect(binding!.calleeName).toBe('GetUser'); + }); + + it('unwraps .await in Rust: let user = get_user().await', () => { + const tree = parse(` + async fn process() { + let user = get_user().await; + } + `, Rust); + const { constructorBindings } = buildTypeEnv(tree, 'rust'); + expect(constructorBindings.length).toBe(1); + expect(constructorBindings[0].varName).toBe('user'); + expect(constructorBindings[0].calleeName).toBe('get_user'); + }); + + it('unwraps await in C#: var user = await svc.GetUserAsync()', () => { + const tree = parse(` + class App { + async void Run() { + var svc = new UserService(); + var user = await svc.GetUserAsync("alice"); + } + } + `, CSharp); + const { constructorBindings } = buildTypeEnv(tree, 'csharp'); + const binding = constructorBindings.find(b => b.varName === 'user'); + expect(binding).toBeDefined(); + expect(binding!.calleeName).toBe('GetUserAsync'); + }); + + it('returns constructor binding for C# var user = GetUser() (standalone call)', () => { + const tree = parse(` + class App { + void Run() { + var user = GetUser("alice"); + } + } + `, CSharp); + const { constructorBindings } = buildTypeEnv(tree, 'csharp'); + const binding = constructorBindings.find(b => b.varName === 'user'); + expect(binding).toBeDefined(); + expect(binding!.calleeName).toBe('GetUser'); + }); + }); + + describe('assignment chain propagation (Tier 2, depth-1)', () => { + it('propagates explicit annotation: const a: User = ...; const b = a → b is User', () => { + const tree = parse(` + const a: User = getUser(); + const b = a; + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'a')).toBe('User'); + expect(flatGet(env, 'b')).toBe('User'); + }); + + it('propagates constructor inference: const a = new User(); const b = a → b is User', () => { + const tree = parse(` + const a = new User(); + const b = a; + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'a')).toBe('User'); + expect(flatGet(env, 'b')).toBe('User'); + }); + + it('depth-2 in declaration order resolves because single pass iterates sequentially', () => { + // b = a → resolved (a has User), c = b → also resolved because the same + // pass sets b before processing c (declarations are always in order). + // The "depth-1" limit applies to out-of-order or cyclic references. + const tree = parse(` + const a: User = getUser(); + const b = a; + const c = b; + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'a')).toBe('User'); + expect(flatGet(env, 'b')).toBe('User'); + expect(flatGet(env, 'c')).toBe('User'); + }); + + it('propagates typed function parameter to local alias', () => { + const tree = parse(` + function process(user: User) { + const alias = user; + alias.save(); + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // 'alias' should get User from the parameter 'user' + const scopeKey = [...env.keys()].find(k => k.startsWith('process@')); + expect(scopeKey).toBeDefined(); + expect(env.get(scopeKey!)?.get('user')).toBe('User'); + expect(env.get(scopeKey!)?.get('alias')).toBe('User'); + }); + + it('propagates file-level typed variable to local alias inside function', () => { + const tree = parse(` + const config: Config = getConfig(); + function process() { + const cfg = config; + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // cfg in process scope picks up Config from the file-level config binding + const scopeKey = [...env.keys()].find(k => k.startsWith('process@')); + expect(scopeKey).toBeDefined(); + expect(env.get(scopeKey!)?.get('cfg')).toBe('Config'); + }); + + it('does not propagate when RHS is a call expression (not a plain identifier)', () => { + const tree = parse(` + const x = getUser(); + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // getUser() is a call_expression — should not create a binding + expect(flatGet(env, 'x')).toBeUndefined(); + }); + }); + + describe('stripNullable', () => { + it('strips User | null → User', () => { + expect(stripNullable('User | null')).toBe('User'); + }); + + it('strips User | undefined → User', () => { + expect(stripNullable('User | undefined')).toBe('User'); + }); + + it('strips User | null | undefined → User', () => { + expect(stripNullable('User | null | undefined')).toBe('User'); + }); + + it('strips User? → User', () => { + expect(stripNullable('User?')).toBe('User'); + }); + + it('passes through User unchanged', () => { + expect(stripNullable('User')).toBe('User'); + }); + + it('refuses genuine union User | Repo → undefined', () => { + expect(stripNullable('User | Repo')).toBeUndefined(); + }); + + it('returns undefined for null alone', () => { + expect(stripNullable('null')).toBeUndefined(); + }); + + it('returns undefined for empty string', () => { + expect(stripNullable('')).toBeUndefined(); + }); + + it('strips User | void → User', () => { + expect(stripNullable('User | void')).toBe('User'); + }); + + it('strips User | None → User (Python)', () => { + expect(stripNullable('User | None')).toBe('User'); + }); + + it('strips User | nil → User (Ruby)', () => { + expect(stripNullable('User | nil')).toBe('User'); + }); + + it('strips User | void | nil → User (multiple nullable keywords)', () => { + expect(stripNullable('User | void | nil')).toBe('User'); + }); + + it('returns undefined for None alone', () => { + expect(stripNullable('None')).toBeUndefined(); + }); + + it('returns undefined for nil alone', () => { + expect(stripNullable('nil')).toBeUndefined(); + }); + + it('returns undefined for void alone', () => { + expect(stripNullable('void')).toBeUndefined(); + }); + + it('returns undefined for undefined alone', () => { + expect(stripNullable('undefined')).toBeUndefined(); + }); + + it('strips nullable suffix with spaces: User ? → User', () => { + expect(stripNullable(' User? ')).toBe('User'); + }); + + it('returns undefined for all-nullable union: null | undefined | void', () => { + expect(stripNullable('null | undefined | void')).toBeUndefined(); + }); + + it('refuses triple non-null union: User | Repo | Service', () => { + expect(stripNullable('User | Repo | Service')).toBeUndefined(); + }); + }); + + // ── Assignment chain: reverse-order depth limitation ────────────────── + + describe('assignment chain — reverse-order limitation', () => { + it('resolves reverse-declared Tier 2→Tier 0 (Tier 0 set during walk, before post-walk)', () => { + // Even though b = a appears before a: User in source, a's Tier 0 binding + // is set during the AST walk. The post-walk Tier 2 loop runs after all + // Tier 0/1 bindings exist, so b = a resolves. + const tree = parse(` + function process() { + const b = a; + const a: User = getUser(); + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + const scopeKey = [...env.keys()].find(k => k.startsWith('process@')); + expect(scopeKey).toBeDefined(); + expect(env.get(scopeKey!)?.get('a')).toBe('User'); + expect(env.get(scopeKey!)?.get('b')).toBe('User'); + }); + + it('does NOT resolve reverse-ordered Tier 2 chains (b = a, a = c, c: User)', () => { + // Two chained Tier 2 assignments in reverse source order. + // Post-walk iterates source order: b = a (a not yet resolved) → fails, + // then a = c (c is Tier 0) → succeeds. b stays unresolved. + const tree = parse(` + function process() { + const b = a; + const a = c; + const c: User = getUser(); + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + const scopeKey = [...env.keys()].find(k => k.startsWith('process@')); + expect(scopeKey).toBeDefined(); + expect(env.get(scopeKey!)?.get('c')).toBe('User'); + expect(env.get(scopeKey!)?.get('a')).toBe('User'); + // b should NOT resolve — reverse Tier 2 chain + expect(env.get(scopeKey!)?.get('b')).toBeUndefined(); + }); + }); + + // ── Assignment chain: per-language coverage for refactored code ──────── + + describe('assignment chain — Go var_spec form', () => { + it('propagates var b = a when a has a known type (var_spec)', () => { + const tree = parse(` + package main + func process() { + var a User + var b = a + } + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'a')).toBe('User'); + expect(flatGet(env, 'b')).toBe('User'); + }); + }); + + describe('assignment chain — C# equals_value_clause', () => { + it('propagates var alias = u when u has a known type', () => { + const tree = parse(` + class App { + void Process() { + User u = new User(); + var alias = u; + } + } + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'alias')).toBe('User'); + }); + }); + + describe('assignment chain — Kotlin property_declaration', () => { + it('propagates val alias = u when u has an explicit type annotation', () => { + const tree = parse(` + fun process() { + val u: User = User() + val alias = u + } + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'alias')).toBe('User'); + }); + + it('propagates val alias = u inside a class method with explicit type', () => { + const tree = parse(` + class Service { + fun process() { + val u: User = User() + val alias = u + } + } + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'alias')).toBe('User'); + }); + }); + + describe('assignment chain — Java variable_declarator', () => { + it('propagates var alias = u when u has an explicit type', () => { + const tree = parse(` + class App { + void process() { + User u = new User(); + var alias = u; + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'alias')).toBe('User'); + }); + }); + + describe('assignment chain — Python identifier', () => { + it('propagates alias = u when u has a type annotation', () => { + const tree = parse(` +def process(): + u: User = get_user() + alias = u + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'alias')).toBe('User'); + }); + + it('propagates walrus alias := u when u has a type annotation', () => { + const tree = parse(` +def process(): + u: User = get_user() + if (alias := u): + pass + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'alias')).toBe('User'); + }); + }); + + describe('assignment chain — Rust let_declaration', () => { + it('propagates let alias = u when u has a type annotation', () => { + const tree = parse(` + fn process() { + let u: User = User::new(); + let alias = u; + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'alias')).toBe('User'); + }); + }); + + describe('assignment chain — PHP variable_name', () => { + it('propagates $alias = $u when $u has a type from new', () => { + const tree = parse(`<?php + function process() { + $u = new User(); + $alias = $u; + } + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$u')).toBe('User'); + expect(flatGet(env, '$alias')).toBe('User'); + }); + }); + + describe('assignment chain — Ruby assignment', () => { + it('captures assignment of simple identifier for pending propagation', () => { + // Ruby assignment chains: alias_user = user where user is a simple identifier. + // In unit tests (no SymbolTable), constructor bindings are pending — so we test + // that the extractor captures the assignment relationship correctly. + // The actual propagation is tested via integration tests where User.new resolves. + const tree = parse(` +def process(user) + alias_user = user + alias_user.save +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + // Without a known type for 'user' (no annotation in Ruby), alias_user stays undefined. + // This verifies the extractor doesn't crash or produce false bindings. + expect(flatGet(env, 'alias_user')).toBeUndefined(); + }); + + it('does not capture assignment from call expression (not a plain identifier)', () => { + const tree = parse(` +def process + user = get_user() + alias_user = user +end +`, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + // get_user() is a call — user has no resolved type, so alias_user should not resolve either + expect(flatGet(env, 'alias_user')).toBeUndefined(); + }); + }); + + // ── lookupInEnv with nullable stripping ─────────────────────────────── + + describe('lookup resolves through nullable stripping', () => { + it('TypeScript: lookup strips User | null to User', () => { + const tree = parse(` + function process(user: User | null) { + user.save(); + } + `, TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + // Find the call node for .save() + const { env } = typeEnv; + const scopeKey = [...env.keys()].find(k => k.startsWith('process@')); + expect(scopeKey).toBeDefined(); + // The raw env stores 'User' because extractSimpleTypeName already unwraps union_type + expect(env.get(scopeKey!)?.get('user')).toBe('User'); + }); + + it('Python: lookup strips User | None to User', () => { + const tree = parse(` +def process(): + user: User | None = get_user() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + // Python 3.10+ union syntax is stored as raw text "User | None" + // which stripNullable resolves at lookup time + const rawVal = flatGet(env, 'user'); + expect(rawVal).toBeDefined(); + // Either already unwrapped by AST, or stored as raw text for stripNullable + expect(stripNullable(rawVal!)).toBe('User'); + }); + }); + + // ── extractSimpleTypeName: nullable wrapper unwrapping ──────────────── + + describe('extractSimpleTypeName — nullable wrapper unwrapping', () => { + it('unwraps Java Optional<User> → User', () => { + const tree = parse(` + class App { + void process() { + Optional<User> user = findUser(); + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('unwraps Rust Option<User> → User', () => { + const tree = parse(` + fn process() { + let user: Option<User> = find_user(); + } + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does NOT unwrap List<User> — containers stay as List', () => { + const tree = parse(` + class App { + void process() { + List<User> users = getUsers(); + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'users')).toBe('List'); + }); + + it('does NOT unwrap Map<String, User> — containers stay as Map', () => { + const tree = parse(` + class App { + void process() { + Map<String, User> lookup = getLookup(); + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'lookup')).toBe('Map'); + }); + + it('does NOT unwrap CompletableFuture<User> — async wrappers stay', () => { + const tree = parse(` + class App { + void process() { + CompletableFuture<User> future = fetchUser(); + } + } + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'future')).toBe('CompletableFuture'); + }); + + it('unwraps TypeScript extractSimpleTypeName directly for generic_type', () => { + // Parse a Java Optional<User> and grab the type node to test extractSimpleTypeName + parser.setLanguage(Java); + const tree = parser.parse(`class A { void f() { Optional<User> x = null; } }`); + // Navigate to the type node: class > body > method > body > local_variable_declaration > type + const method = tree.rootNode.firstNamedChild?.lastNamedChild?.firstNamedChild; + const decl = method?.lastNamedChild?.firstNamedChild; + const typeNode = decl?.childForFieldName('type'); + if (typeNode) { + expect(extractSimpleTypeName(typeNode)).toBe('User'); + } + }); + }); + + // ── C++ assignment chain propagation ────────────────────────────────── + + describe('assignment chain — C++ auto alias', () => { + it('propagates auto alias = u when u has an explicit type', () => { + const tree = parse(` + void process() { + User u; + auto alias = u; + } + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'alias')).toBe('User'); + }); + }); + + // ── Tier 1c: for-loop element type inference ─────────────────────────── + + describe('for-loop element type inference (Tier 1c) — TypeScript', () => { + it('infers loop variable type from User[] parameter annotation (for...of)', () => { + const tree = parse(` + function process(users: User[]) { + for (const user of users) { + user.save(); + } + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers loop variable type from Array<User> parameter annotation (for...of)', () => { + const tree = parse(` + function process(users: Array<User>) { + for (const user of users) { + user.save(); + } + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does NOT bind loop variable for for...in (produces string keys, not elements)', () => { + const tree = parse(` + function process(users: User[]) { + for (const key in users) { + console.log(key); + } + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // for...in yields string keys — extractor must NOT bind 'key' to User + expect(flatGet(env, 'key')).toBeUndefined(); + }); + + it('does not infer type when iterable variable has no known type in scope', () => { + const tree = parse(` + function process(users: any) { + for (const user of users) { + user.save(); + } + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + + it('infers loop variable from a locally declared const with User[] annotation', () => { + const tree = parse(` + function process() { + const users: User[] = getUsers(); + for (const user of users) { + user.save(); + } + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // Note: users itself is stored with no binding (extractSimpleTypeName returns undefined + // for array_type), but the for-loop extractor uses AST walking to resolve the element type. + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers loop variable from readonly User[] parameter', () => { + const tree = parse(` + function process(users: readonly User[]) { + for (const user of users) { + user.save(); + } + } + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('for-loop element type inference (Tier 1c) — Python', () => { + it('infers loop variable type from List[User] parameter annotation', () => { + const tree = parse(` +def process(users: List[User]): + for user in users: + user.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers loop variable type from Sequence[User] annotation style', () => { + const tree = parse(` +def process(users: Sequence[User]): + for user in users: + user.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer type when iterable parameter has no annotation', () => { + const tree = parse(` +def process(users): + for user in users: + user.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + + it('infers loop variable from a locally annotated variable', () => { + const tree = parse(` +def process(): + users: List[User] = get_users() + for user in users: + user.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + // List[User] → extractSimpleTypeName returns 'List' (base name), stored as 'List' + // extractElementTypeFromString('List') → undefined (no brackets in the string) + // So user is unresolved unless users is stored as 'List[User]' raw. + // The locally annotated var stores the base type 'List' via extractSimpleTypeName. + // This test documents the actual behavior. + const usersType = flatGet(env, 'users'); + expect(usersType).toBeDefined(); // users has a type annotation + }); + }); + + describe('for-loop element type inference (Tier 1c) — Go', () => { + it('infers loop variable type from []User slice parameter (_, user := range users)', () => { + const tree = parse(` +package main +func process(users []User) { + for _, user := range users { + user.Save() + } +} + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does NOT infer element type for single-var slice range (yields index, not element)', () => { + const tree = parse(` +package main +func process(users []User) { + for user := range users { + user.Save() + } +} + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + // In Go, `for v := range slice` gives the INDEX (int), not the element. + expect(flatGet(env, 'user')).toBeUndefined(); + }); + + it('infers loop variable from map range (_, v := range myMap)', () => { + const tree = parse(` +package main +func process(myMap map[string]User) { + for _, v := range myMap { + v.Save() + } +} + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + expect(flatGet(env, 'v')).toBe('User'); + }); + + it('does NOT infer element type for single-var map range (yields key, not value)', () => { + const tree = parse(` +package main +func process(myMap map[string]User) { + for k := range myMap { + _ = k + } +} + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + // Single-var map range gives the KEY, not the value + expect(flatGet(env, 'k')).toBeUndefined(); + }); + + it('does not infer type for C-style for loops (no range_clause)', () => { + const tree = parse(` +package main +func process() { + for i := 0; i < 10; i++ { + } +} + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + // C-style for loop has no range_clause — extractor must return early + expect(flatGet(env, 'i')).toBeUndefined(); + }); + + it('does not infer type when iterable has no annotation in scope', () => { + const tree = parse(` +package main +func process() { + users := getUsers() + for _, user := range users { + user.Save() + } +} + `, Go); + const { env } = buildTypeEnv(tree, 'go'); + // users has no type annotation — only a constructor binding candidate + // Without a resolved type for users, user cannot be inferred + expect(flatGet(env, 'user')).toBeUndefined(); + }); + }); + + describe('for-loop element type inference (Tier 1c) — Rust', () => { + it('infers loop variable from Vec<User> parameter (for user in &users)', () => { + const tree = parse(` +fn process(users: Vec<User>) { + for user in &users { + user.save(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('infers loop variable from &[User] slice parameter', () => { + const tree = parse(` +fn process(users: &[User]) { + for user in users { + user.save(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer type for range expression (0..10)', () => { + const tree = parse(` +fn process() { + for i in 0..10 { + println!("{}", i); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'i')).toBeUndefined(); + }); + + it('does not infer type when iterable has no annotation', () => { + const tree = parse(` +fn process() { + let users = get_users(); + for user in &users { + user.save(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + }); + + describe('for-loop element type inference (Tier 1c) — C#', () => { + it('infers loop variable from var foreach with List<User> parameter', () => { + const tree = parse(` +using System.Collections.Generic; +class Foo { + void Process(List<User> users) { + foreach (var user in users) { + user.Save(); + } + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('still resolves explicit type foreach (regression)', () => { + const tree = parse(` +class Foo { + void Process(List<User> users) { + foreach (User user in users) { + user.Save(); + } + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer type when iterable has no annotation', () => { + const tree = parse(` +class Foo { + void Process() { + var users = GetUsers(); + foreach (var user in users) { + user.Save(); + } + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + }); + + describe('for-loop element type inference (Tier 1c) — Kotlin', () => { + it('infers loop variable from unannotated for with List<User> parameter', () => { + const tree = parse(` +fun process(users: List<User>) { + for (user in users) { + user.save() + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('still resolves explicit type annotation (regression)', () => { + const tree = parse(` +fun process(users: List<User>) { + for (user: User in users) { + user.save() + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer type when iterable has no annotation', () => { + const tree = parse(` +fun process() { + val users = getUsers() + for (user in users) { + user.save() + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + }); + + describe('for-loop element type inference (Tier 1c) — Java', () => { + it('still resolves explicit type enhanced-for (regression)', () => { + const tree = parse(` +class Foo { + void process(List<User> users) { + for (User user : users) { + user.save(); + } + } +} + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('does not infer type when iterable has no annotation', () => { + const tree = parse(` +class Foo { + void process() { + var users = getUsers(); + for (var user : users) { + user.save(); + } + } +} + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBeUndefined(); + }); + }); + + describe('previously-skipped limitations (now resolved)', () => { + it('TS destructured for-of: for (const [k, v] of entries) — last-child heuristic', () => { + // array_pattern handled by binding last named child to element type. + // Map<string, User> resolves to 'User' via last generic type arg. + const tree = parse(` +function process(entries: Map<string, User>) { + for (const [key, user] of entries) { + user.save(); + } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('Python tuple unpacking: for key, value in dict.items() — call iterable + pattern_list', () => { + // call iterable: data.items() → extract receiver 'data' for type lookup. + // pattern_list: bind last named child to element type. + // dict[str, User] resolves to 'User' via last generic type arg. + const tree = parse(` +def process(data: dict[str, User]): + for key, user in data.items(): + user.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('Python enumerate(dict.items()): for i, k, v — skips int index, binds value var to User', () => { + // enumerate() wraps the iterable: right node is call with fn='enumerate', not fn.attribute. + // Without enumerate() support, iterableName is never set → v stays unbound. + // With the fix: unwrap enumerate → inner call → data.items() → v binds to User. + const tree = parse(` +def process(data: dict[str, User]): + for i, k, v in enumerate(data.items()): + v.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'v')).toBe('User'); + // i is the int index from enumerate — must NOT be bound to User + expect(flatGet(env, 'i')).toBeUndefined(); + }); + + it('Python enumerate(dict.items()) with nested tuple: for i, (k, v) — binds v to User', () => { + // Nested tuple pattern: `(k, v)` is a tuple_pattern inside the pattern_list. + // AST: pattern_list > [identifier('i'), tuple_pattern > [identifier('k'), identifier('v')]] + // Must descend into tuple_pattern to extract v, not just collect top-level identifiers. + const tree = parse(` +def process(data: dict[str, User]): + for i, (k, v) in enumerate(data.items()): + v.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'v')).toBe('User'); + expect(flatGet(env, 'i')).toBeUndefined(); + }); + + it('Python enumerate with parenthesized tuple: for (k, v) in enumerate(users) — binds v to User', () => { + // Parenthesized tuple pattern: `(k, v)` is a tuple_pattern, not pattern_list. + // AST: for_statement > left: tuple_pattern > [identifier('k'), identifier('v')] + // Must handle tuple_pattern as top-level left node, not just nested inside pattern_list. + const tree = parse(` +def process(users: List[User]): + for (k, v) in enumerate(users): + v.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + // enumerate yields (index, element) — k is int (unbound), v is User + expect(flatGet(env, 'v')).toBe('User'); + expect(flatGet(env, 'k')).toBeUndefined(); + }); + + it('TS instanceof narrowing: if (x instanceof User) — first-writer-wins, not block-scoped', () => { + // Binds x to User via extractPatternBinding on binary_expression. + // Only works when x has no prior type binding in scopeEnv. + // True block-level scoping (overwriting existing bindings) is Phase 5. + const tree = parse(` +function process(x) { + if (x instanceof User) { + x.save(); + } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'x')).toBe('User'); + }); + + it('Rust for with .iter(): for user in users.iter() — call_expression iterable', () => { + // Extracts receiver from call_expression > field_expression > identifier. + // .iter()/.into_iter()/.iter_mut() is the dominant Rust iteration pattern. + const tree = parse(` +fn process(users: Vec<User>) { + for user in users.iter() { + user.save(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('method-aware type arg selection (.keys() vs .values())', () => { + it('TS for-of map.values() resolves to value type (User)', () => { + const tree = parse(` +function process(data: Map<string, User>) { + for (const user of data.values()) { + user.save(); + } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('TS for-of map.keys() resolves to key type (string)', () => { + const tree = parse(` +function process(data: Map<string, User>) { + for (const key of data.keys()) { + key.trim(); + } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'key')).toBe('string'); + }); + + it('Python for key in data.keys() resolves to key type (str)', () => { + const tree = parse(` +def process(data: dict[str, User]): + for key in data.keys(): + key.strip() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'key')).toBe('str'); + }); + + it('Python for user in data.values() resolves to value type (User)', () => { + const tree = parse(` +def process(data: dict[str, User]): + for user in data.values(): + user.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('Rust for key in map.keys() resolves to key type (String)', () => { + const tree = parse(` +fn process(data: HashMap<String, User>) { + for key in data.keys() { + key.len(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'key')).toBe('String'); + }); + + it('Rust for user in map.values() resolves to value type (User)', () => { + const tree = parse(` +fn process(data: HashMap<String, User>) { + for user in data.values() { + user.save(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('container descriptor-aware type arg selection', () => { + it('HashMap.keys() resolves to key type (String) via descriptor', () => { + const tree = parse(` +fn process(data: HashMap<String, User>) { + for key in data.keys() { + key.len(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'key')).toBe('String'); + }); + + it('HashMap.values() resolves to value type (User) via descriptor', () => { + const tree = parse(` +fn process(data: HashMap<String, User>) { + for user in data.values() { + user.save(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('Vec.iter() resolves to element type (User) — arity 1 always returns last', () => { + const tree = parse(` +fn process(users: Vec<User>) { + for user in users.iter() { + user.save(); + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('unknown container falls back to last-arg heuristic', () => { + // MyCache is not in CONTAINER_DESCRIPTORS, so .keys() still returns first via fallback + const tree = parse(` +function process(cache: MyCache<string, User>) { + for (const key of cache.keys()) { + key.trim(); + } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'key')).toBe('string'); + }); + }); + + describe('for-loop Phase 2 enhancements', () => { + it('TS object destructuring skip: for (const { id, name } of users) — no binding produced', () => { + const tree = parse(` +function process(users: User[]) { + for (const { id, name } of users) { + console.log(id, name); + } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // Object destructuring should NOT produce bindings — field types are unknown + expect(flatGet(env, 'id')).toBeUndefined(); + expect(flatGet(env, 'name')).toBeUndefined(); + }); + + it('TS member access: for (const user of this.users) with users: User[] param — resolves', () => { + const tree = parse(` +function process(users: User[]) { + for (const user of this.users) { + user.save(); + } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('Python member access: for user in self.users with users: List[User] param — resolves', () => { + const tree = parse(` +def process(users: List[User]): + for user in self.users: + user.save() + `, Python); + const { env } = buildTypeEnv(tree, 'python'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('C++ structured bindings: for (auto& [key, value] : map) with map<string, User> param — binds value', () => { + const tree = parse(` +void process(std::map<std::string, User>& map) { + for (auto& [key, value] : map) { + value.save(); + } +} + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'value')).toBe('User'); + }); + + it('C++ structured bindings: exact App.cpp fixture — binds user and repo', () => { + const tree = parse(` +#include "User.h" +#include "Repo.h" +#include <map> +#include <string> +#include <vector> + +void processUserMap(std::map<std::string, User> userMap) { + for (auto& [key, user] : userMap) { + user.save(); + } +} + +void processRepoMap(std::map<std::string, Repo> repoMap) { + for (const auto& [key, repo] : repoMap) { + repo.save(); + } +} + `, CPP); + const { env } = buildTypeEnv(tree, 'cpp'); + expect(flatGet(env, 'user')).toBe('User'); + expect(flatGet(env, 'repo')).toBe('Repo'); + }); + }); + + describe('known limitations (documented skip tests)', () => { + it.skip('Ruby block parameter: users.each { |user| } — closure param inference, different feature', () => { + // Not a for-loop; .each { |user| } is a method call with a block. + // Requires closure parameter inference — a different feature category + // applicable to Ruby, Swift closures, Kotlin lambdas, and Java lambdas. + const tree = parse(` +def process(users) + users.each { |user| user.save } +end + `, Ruby); + const { env } = buildTypeEnv(tree, 'ruby'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('Kotlin when/is pattern binding (Phase 6)', () => { + it('when (x) { is User -> } binds x to User', () => { + const tree = parse(` +fun process(x: Any) { + when (x) { + is User -> x.name + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'x')).toBe('User'); + }); + + it('when (x) { is User -> ...; is Admin -> ... } — last arm overwrites (allowPatternBindingOverwrite)', () => { + const tree = parse(` +fun process(x: Any) { + when (x) { + is User -> x.name + is Admin -> x.role + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + // allowPatternBindingOverwrite means each arm overwrites — last one wins + expect(flatGet(env, 'x')).toBe('Admin'); + }); + + it('when (x) { else -> } — no type check, no pattern binding produced', () => { + const tree = parse(` +fun process() { + val x: String = "" + when (x) { + else -> println(x) + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + // x has type String from its declaration — no pattern binding should narrow it + // (else branch has no type_test node, so extractKotlinPatternBinding never fires) + expect(flatGet(env, 'x')).toBe('String'); + }); + }); + + describe('Kotlin for-loop HashMap.values resolution (Phase 6)', () => { + it('for (user in data.values) binds user to User via HashMap<String, User>', () => { + const tree = parse(` +fun processValues(data: HashMap<String, User>) { + for (user in data.values) { + user.save() + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('for (user in users) binds user to User via List<User> param', () => { + const tree = parse(` +fun processList(users: List<User>) { + for (user in users) { + user.save() + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('Java switch pattern variable (Phase 6)', () => { + it('switch (obj) { case User u -> } binds u to User', () => { + const tree = parse(` +class App { + void process(Object obj) { + switch (obj) { + case User u -> u.save(); + } + } +} + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'u')).toBe('User'); + }); + + it('switch (obj) { case User u -> ...; case Admin a -> ... } — both bind', () => { + const tree = parse(` +class App { + void process(Object obj) { + switch (obj) { + case User u -> u.save(); + case Admin a -> a.manage(); + } + } +} + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'u')).toBe('User'); + expect(flatGet(env, 'a')).toBe('Admin'); + }); + + it('switch (x) { case 42 -> ... } — no pattern variable, no binding', () => { + const tree = parse(` +class App { + void process(Object x) { + switch (x) { + case 42 -> System.out.println("answer"); + } + } +} + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + // Only the parameter x:Object should exist, no extra bindings from case 42 + expect(flatGet(env, 'x')).toBe('Object'); + }); + + it('obj instanceof User user — regression: still works after type_pattern addition', () => { + const tree = parse(` +class App { + void process(Object obj) { + if (obj instanceof User user) { + user.save(); + } + } +} + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('new container descriptors (Phase 6.1)', () => { + it('Collection<User> resolves element type via descriptor (arity 1)', () => { + const tree = parse(` +using System.Collections.ObjectModel; +public class App { + public void Process(Collection<User> users) { + foreach (var user in users) { + user.Save(); + } + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('MutableMap<String, User>.values() resolves to User via descriptor (arity 2)', () => { + const tree = parse(` +fun process(data: MutableMap<String, User>) { + for (user in data.values()) { + user.save() + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('MutableList<User> resolves element type via descriptor', () => { + const tree = parse(` +fun process(users: MutableList<User>) { + for (user in users) { + user.save() + } +} + `, Kotlin); + const { env } = buildTypeEnv(tree, 'kotlin'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('SortedSet<User> resolves element type via descriptor (C#)', () => { + const tree = parse(` +using System.Collections.Generic; +public class App { + public void Process(SortedSet<User> users) { + foreach (var user in users) { + user.Save(); + } + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('Stream<User> resolves element type via descriptor (Java)', () => { + const tree = parse(` +class App { + void process(Stream<User> users) { + for (User user : users.toList()) { + user.save(); + } + } +} + `, Java); + const { env } = buildTypeEnv(tree, 'java'); + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('C# recursive_pattern binding (Phase 6.1)', () => { + it('obj is User { Name: "Alice" } u — binds u to User', () => { + const tree = parse(` +public class App { + public void Process(object obj) { + if (obj is User { Name: "Alice" } u) { + u.Save(); + } + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'u')).toBe('User'); + }); + + it('switch expression with recursive_pattern — binds r to Repo', () => { + const tree = parse(` +public class App { + public void Process(object obj) { + var result = obj switch { + Repo { Name: "main" } r => r.Save(), + _ => false + }; + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'r')).toBe('Repo'); + }); + + it('recursive_pattern without designation — no pattern binding produced', () => { + const tree = parse(` +public class App { + public void Process(object obj) { + if (obj is User { Name: "Alice" }) { + } + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + // obj → object from the parameter, but no pattern binding + expect(flatGet(env, 'obj')).toBe('object'); + expect(flatSize(env)).toBe(1); // only the parameter binding + }); + }); + + describe('C# await foreach (Phase 6.1)', () => { + it('await foreach (var user in users) — same node type as foreach, resolves element type', () => { + const tree = parse(` +using System.Collections.Generic; +public class App { + public async Task Process(IAsyncEnumerable<User> users) { + await foreach (var user in users) { + user.Save(); + } + } +} + `, CSharp); + const { env } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('foreach (var user in this.data.Values) — nested member access with container property', () => { + const tree = parse(` +using System.Collections.Generic; +public class App { + private Dictionary<string, User> data; + public void ProcessValues() { + foreach (var user in this.data.Values) { + user.Save(); + } + } +} + `, CSharp); + const { env, lookup } = buildTypeEnv(tree, 'csharp'); + expect(flatGet(env, 'user')).toBe('User'); + // Verify lookup works from the call site (user.Save()) + const saveCall = tree.rootNode.descendantsOfType('invocation_expression')[0]; + expect(lookup('user', saveCall)).toBe('User'); + }); + }); + + describe('TypeScript class field declaration (Phase 6.1)', () => { + it('class field with array type — for-loop resolves element type via declarationTypeNodes', () => { + const tree = parse(` +class UserService { + private users: User[] = []; + processUsers() { + for (const user of this.users) { + user.save(); + } + } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + // User[] is an array_type — extractSimpleTypeName returns undefined (no simple base name). + // But declarationTypeNodes captures the raw AST node, so for-loop resolution + // uses Strategy 1 (extractTsElementTypeFromAnnotation) to resolve the element type. + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('class field with generic type annotation — binds field name to base type', () => { + const tree = parse(` +class RepoService { + repos: Map<string, Repo> = new Map(); +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'repos')).toBe('Map'); + }); + }); + + describe('PHP foreach $this->property (Phase 7.4 — Strategy C)', () => { + it('resolves loop variable from @var User[] property without @param workaround', () => { + const tree = parse(`<?php +class App { + /** @var User[] */ + private $users; + public function process(): void { + foreach ($this->users as $user) { + $user->save(); + } + } +} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$user')).toBe('User'); + }); + + it('does not bind from unknown $this->property (conservative)', () => { + const tree = parse(`<?php +class App { + private $unknownProp; + public function process(): void { + foreach ($this->unknownProp as $item) { + $item->save(); + } + } +} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + expect(flatGet(env, '$item')).toBeUndefined(); + }); + + it('multi-class file: resolves correct property for each class', () => { + const tree = parse(`<?php +class A { + /** @var User[] */ + private $items; + public function processA(): void { + foreach ($this->items as $item) { + $item->save(); + } + } +} +class B { + /** @var Order[] */ + private $items; + public function processB(): void { + foreach ($this->items as $item) { + $item->submit(); + } + } +} + `, PHP.php); + const { env } = buildTypeEnv(tree, 'php'); + // Both $item bindings exist but may share the same key if scoped to method name + // Conservative: just verify at least one resolves correctly + expect(flatGet(env, '$item')).toBeDefined(); + }); + }); + + describe('match arm scoping — first-writer-wins regression', () => { + it('Rust: first match arm binding wins, later arms do not overwrite', () => { + const tree = parse(` +fn process(opt: Option<User>) { + match opt { + Some(user) => user.save(), + None => {}, + } +} + `, Rust); + const { env } = buildTypeEnv(tree, 'rust'); + // user should be typed from the first arm (Some unwrap) + // Known limitation: binding leaks across arms (first-writer-wins) + expect(flatGet(env, 'user')).toBe('User'); + }); + }); + + describe('performance optimizations — coverage for new code paths', () => { + it('fastStripNullable: passes through simple identifier without stripping', () => { + const tree = parse('function f(user: User) { user.save(); }', TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + // lookup exercises fastStripNullable — "User" has no | or ? markers + const callNode = tree.rootNode.descendantForIndex(tree.rootNode.text.indexOf('save')); + expect(typeEnv.lookup('user', callNode)).toBe('User'); + }); + + it('fastStripNullable: strips nullable union type via full stripNullable', () => { + const tree = parse('function f(user: User | null) { user.save(); }', TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + const callNode = tree.rootNode.descendantForIndex(tree.rootNode.text.indexOf('save')); + expect(typeEnv.lookup('user', callNode)).toBe('User'); + }); + + it('fastStripNullable: rejects bare nullable keyword', () => { + const tree = parse('function f(x: null) { x.save(); }', TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + const callNode = tree.rootNode.descendantForIndex(tree.rootNode.text.indexOf('save')); + expect(typeEnv.lookup('x', callNode)).toBeUndefined(); + }); + + it('fastStripNullable: strips optional type suffix', () => { + const tree = parse(` +class Foo { + process(user: User) { + user.save(); + } +} + `, TypeScript.typescript); + const typeEnv = buildTypeEnv(tree, 'typescript'); + const callNode = tree.rootNode.descendantForIndex(tree.rootNode.text.indexOf('save')); + expect(typeEnv.lookup('user', callNode)).toBe('User'); + }); + + it('SKIP_SUBTREE_TYPES: string literal subtrees do not affect type extraction', () => { + const tree = parse(` +function f(user: User) { + const msg = "hello world this is a long string"; + user.save(); +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'user')).toBe('User'); + }); + + it('interestingNodeTypes: non-declaration nodes skip extractTypeBinding', () => { + // Large code with many non-interesting nodes (binary expressions, calls, etc.) + const tree = parse(` +function calculate(service: Service) { + const a = 1 + 2 + 3; + const b = true && false; + if (a > b) { service.run(); } +} + `, TypeScript.typescript); + const { env } = buildTypeEnv(tree, 'typescript'); + expect(flatGet(env, 'service')).toBe('Service'); + }); + }); + +}); diff --git a/gitnexus/test/unit/utils.test.ts b/gitnexus/test/unit/utils.test.ts new file mode 100644 index 0000000000..9db01a2201 --- /dev/null +++ b/gitnexus/test/unit/utils.test.ts @@ -0,0 +1,39 @@ +import { describe, it, expect } from 'vitest'; +import { generateId } from '../../src/lib/utils.js'; + +describe('generateId', () => { + it('creates id from label and name', () => { + expect(generateId('Function', 'main')).toBe('Function:main'); + }); + + it('handles labels with various node types', () => { + expect(generateId('File', 'src/index.ts')).toBe('File:src/index.ts'); + expect(generateId('Class', 'UserService')).toBe('Class:UserService'); + expect(generateId('Method', 'getData')).toBe('Method:getData'); + expect(generateId('Folder', 'src')).toBe('Folder:src'); + expect(generateId('Interface', 'IUser')).toBe('Interface:IUser'); + }); + + it('handles special characters in name', () => { + expect(generateId('Function', 'path/to/file.ts:init')).toBe('Function:path/to/file.ts:init'); + }); + + it('handles empty strings', () => { + expect(generateId('', '')).toBe(':'); + expect(generateId('', 'name')).toBe(':name'); + expect(generateId('label', '')).toBe('label:'); + }); + + it('handles relationship IDs', () => { + expect(generateId('CONTAINS', 'Folder:src->File:src/index.ts')).toBe('CONTAINS:Folder:src->File:src/index.ts'); + }); + + it('handles multi-language node types', () => { + expect(generateId('Struct', 'Point')).toBe('Struct:Point'); + expect(generateId('Trait', 'Display')).toBe('Trait:Display'); + expect(generateId('Impl', 'Display for Point')).toBe('Impl:Display for Point'); + expect(generateId('Enum', 'Color')).toBe('Enum:Color'); + expect(generateId('Namespace', 'std')).toBe('Namespace:std'); + expect(generateId('Constructor', 'User')).toBe('Constructor:User'); + }); +}); diff --git a/gitnexus/test/utils/hook-test-helpers.ts b/gitnexus/test/utils/hook-test-helpers.ts new file mode 100644 index 0000000000..6f5c5fbfd2 --- /dev/null +++ b/gitnexus/test/utils/hook-test-helpers.ts @@ -0,0 +1,35 @@ +/** + * Shared helpers for hook test files (unit + integration). + */ +import { spawnSync } from 'child_process'; + +export function runHook( + hookPath: string, + input: Record<string, any>, + cwd?: string, +): { stdout: string; stderr: string; status: number | null } { + const result = spawnSync(process.execPath, [hookPath], { + input: JSON.stringify(input), + encoding: 'utf-8', + timeout: 10000, + cwd, + stdio: ['pipe', 'pipe', 'pipe'], + }); + return { + stdout: result.stdout || '', + stderr: result.stderr || '', + status: result.status, + }; +} + +export function parseHookOutput( + stdout: string, +): { hookEventName?: string; additionalContext?: string } | null { + if (!stdout.trim()) return null; + try { + const parsed = JSON.parse(stdout.trim()); + return parsed.hookSpecificOutput || null; + } catch { + return null; + } +} diff --git a/gitnexus/test/vitest.d.ts b/gitnexus/test/vitest.d.ts new file mode 100644 index 0000000000..63f658e6bc --- /dev/null +++ b/gitnexus/test/vitest.d.ts @@ -0,0 +1,7 @@ +import 'vitest'; + +declare module 'vitest' { + export interface ProvidedContext { + lbugDbPath: string; + } +} diff --git a/gitnexus/tsconfig.test.json b/gitnexus/tsconfig.test.json new file mode 100644 index 0000000000..425ff7485e --- /dev/null +++ b/gitnexus/tsconfig.test.json @@ -0,0 +1,10 @@ +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "rootDir": ".", + "noEmit": true, + "types": ["node", "vitest/globals"] + }, + "include": ["src/**/*", "test/**/*"], + "exclude": ["test/fixtures/mini-repo/**", "test/fixtures/sample-code/**"] +} diff --git a/gitnexus/vitest.config.ts b/gitnexus/vitest.config.ts new file mode 100644 index 0000000000..6a2956856f --- /dev/null +++ b/gitnexus/vitest.config.ts @@ -0,0 +1,87 @@ +import { defineConfig } from 'vitest/config'; + +export default defineConfig({ + test: { + // Shared settings — inherited by all projects via extends: true + globalSetup: ['test/global-setup.ts'], + testTimeout: 30000, + hookTimeout: 120000, + pool: 'forks', + globals: true, + teardownTimeout: 3000, + // N-API destructors can crash worker forks on macOS during process exit. + // This is independent of the QueryResult lifetime fix in @ladybugdb/core 0.15.2 — + // it's a vitest forks + native addon interaction where destructors run in + // arbitrary order at exit. Tests themselves pass; only the exit crashes. + // TODO: remove once LadybugDB fixes all N-API destructor ordering issues. + dangerouslyIgnoreUnhandledErrors: true, + + // Coverage stays at root (not supported in project configs) + coverage: { + provider: 'v8', + include: ['src/**/*.ts'], + exclude: [ + 'src/cli/index.ts', // CLI entry point (commander wiring) + 'src/server/**', // HTTP server (requires network) + 'src/core/wiki/**', // Wiki generation (requires LLM) + ], + // Auto-ratchet: vitest bumps thresholds when coverage exceeds them. + // CI will fail if a PR drops below these floors. + thresholds: { + statements: 26, + branches: 23, + functions: 28, + lines: 27, + autoUpdate: true, + }, + }, + + // LadybugDB's native mmap addon causes file-lock conflicts when vitest + // runs lbug test files in parallel forks on Windows. The 'lbug-db' + // project forces sequential execution (fileParallelism: false). + // + // Each file runs in its own fork — the fork exits after the file + // completes, triggering an N-API destructor segfault that is caught + // by dangerouslyIgnoreUnhandledErrors. Tests themselves pass; only + // the exit crashes. This is safer than isolate: false, which causes + // native state corruption after 2-3 open/close cycles in the same fork. + projects: [ + { + extends: true, + test: { + name: 'lbug-db', + include: [ + 'test/integration/lbug-core-adapter.test.ts', + 'test/integration/lbug-pool.test.ts', + 'test/integration/lbug-pool-stability.test.ts', + 'test/integration/local-backend.test.ts', + 'test/integration/local-backend-calltool.test.ts', + 'test/integration/search-core.test.ts', + 'test/integration/search-pool.test.ts', + 'test/integration/augmentation.test.ts', + ], + fileParallelism: false, + sequence: { groupOrder: 1 }, + }, + }, + { + extends: true, + test: { + name: 'default', + sequence: { groupOrder: 2 }, + include: ['test/**/*.test.ts'], + exclude: [ + 'test/integration/lbug-core-adapter.test.ts', + 'test/integration/lbug-pool.test.ts', + 'test/integration/lbug-pool-stability.test.ts', + 'test/integration/local-backend.test.ts', + 'test/integration/local-backend-calltool.test.ts', + 'test/integration/search-core.test.ts', + 'test/integration/search-pool.test.ts', + 'test/integration/augmentation.test.ts', + ], + }, + }, + ], + }, +}); diff --git a/package-lock.json b/package-lock.json index f4c3d0c4b3..9c0b3071ff 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,5 +1,5 @@ { - "name": "GitnexusV2", + "name": "GitNexus", "lockfileVersion": 3, "requires": true, "packages": {} diff --git a/skills.mdm b/skills.mdm new file mode 100644 index 0000000000..e69de29bb2 diff --git a/type-resolution-roadmap.md b/type-resolution-roadmap.md new file mode 100644 index 0000000000..32591d534b --- /dev/null +++ b/type-resolution-roadmap.md @@ -0,0 +1,463 @@ +# Type Resolution Roadmap + +This roadmap describes the next major capabilities needed to evolve GitNexus's type-resolution layer from a strong receiver-disambiguation aid into a broader static-analysis foundation. + +The roadmap assumes the current system already provides: + +- explicit type extraction from declarations and parameters +- initializer / constructor inference +- loop element inference for many languages +- selected pattern binding and narrowing +- comment-based fallbacks in JS/TS, PHP, and Ruby +- constrained return-type-aware receiver inference during call processing + +The remaining work is about **generalisation**, **deeper structure modelling**, and **better propagation**. + +--- + +## Principles for Future Work + +The type system should continue to preserve the qualities that make it practical today: + +- **stay conservative** +- **prefer explainable inference over clever but brittle inference** +- **limit performance overhead during ingestion** +- **keep per-language extractors explicit rather than over-generic** +- **separate "better receiver resolution" from "compiler-grade typing"** + +The goal is not to build a compiler. The goal is to support high-value static analysis for call graphs, impact analysis, context gathering, and downstream graph features. + +--- + +## Near-Term Priority: Generalise Existing Inference + +The next biggest gain is not inventing a new type system layer. It is expanding the inference the system already performs so more constructs can benefit from it. + +### Why this is the right next step + +Today, return-type-aware inference already exists in constrained form inside `call-processor.ts`, and loop element inference already handles many identifier-based iterables. + +The most valuable next move is to let those signals participate in more places, especially: + +- iterable expressions rather than only iterable identifiers +- assignment propagation from call results +- doc-comment-derived file-scope bindings where local scope is insufficient + +--- + +## Phase 7: Cross-Scope and Return-Aware Propagation + +> **Status: COMPLETE** — shipped in `feat/phase7-type-resolution` (commits `ed767e3`, `ca4c6c1`, `d79237e`). + +### Goal + +Allow loop inference and assignment inference to see more than the current function-local environment. + +### Problems this phase addresses + +#### 7A. Iterable expressions in Go and similar cases (shipped as Phase 7.3) + +```go +for _, user := range getUsers() { + user.Save() +} +``` + +The iterable is a call expression, not an identifier with a local binding. + +Resolved: `ReturnTypeLookup` introduced in Phase 7.1 exposes `lookupRawReturnType`. All seven typed-iteration languages (Go, TypeScript, Python, Rust, Java, Kotlin, C#) now unwrap the raw container type string to extract the element type when the iterable is a direct function call. + +#### 7B. File-scope or class-scope iterable typing in PHP (shipped as Phase 7.4) + +```php +foreach ($this->users as $user) { + $user->save(); +} +``` + +If `$this->users` is typed through a class property annotation or file/class-scope doc-comment information, the current local-scope-only path may not be enough. + +Resolved: Strategy C in the PHP `extractForLoopBinding` walks up the AST to the enclosing `class_declaration`, scans the `declaration_list` for a matching `property_declaration`, and extracts the element type from the `@var` PHPDoc comment (or PHP 7.4+ native type field). The `@param` workaround previously required in the fixture is gone. + +#### 7C. Broader use of already-known return types (shipped as Phase 7.1 + 7.2) + +The system can already infer receiver types from uniquely resolved call results in `call-processor.ts`. That needs to be generalised so `TypeEnv` can benefit from it too. + +Resolved: `ReturnTypeLookup` (Phase 7.1) encapsulates `lookupReturnType` / `lookupRawReturnType` and is threaded through `ForLoopExtractorContext` (Phase 7.2) to all for-loop extractors. Phase 7.2 also added the `pendingCallResults` infrastructure (the `PendingAssignment` discriminated union in `types.ts` and the Tier 2b processing loop in `type-env.ts`), but no extractor populates it yet — `var x = f()` propagation is Phase 9 work. + +### Engineering direction (as implemented) + +- introduced `ReturnTypeLookup` interface and `buildReturnTypeLookup` factory in `type-env.ts` +- replaced per-extractor `(node, env)` signature with `ForLoopExtractorContext` context object for extensibility +- added `extractElementTypeFromString` to `shared.ts` as the canonical raw-string container unwrapper +- added PHP Strategy C helper (`findClassPropertyElementType`) scoped to the PHP extractor +- kept all changes backwards-compatible — explicit-type paths are untouched + +### Delivered impact + +- loop inference now works for direct function call iterables in all 7 typed-iteration languages +- PHP `$this->property` foreach is resolved from class-level `@var` without requiring `@param` workarounds +- `pendingCallResults` infrastructure is in place (Tier 2b loop + `PendingAssignment` union) — dormant until an extractor emits `{ kind: 'callResult' }` (Phase 9) + +### Risk level + +**Medium** (as predicted) + +The interface change touched all extractors but remained additive — no existing paths were changed. + +--- + +## Phase 8: Field and Property Type Resolution *(delivered)* + +### Goal + +Model class / struct fields so chained member access can be resolved more accurately. + +### Status + +**Delivered.** One-level, deep, and mixed field+method chain resolution is implemented across 9 languages. Pattern destructuring (8C) remains open. + +#### What shipped + +- **SymbolTable `fieldByOwner` index** — O(1) lookup via `ownerNodeId\0fieldName` key. Properties excluded from `globalIndex` to prevent namespace pollution. *(Q1 resolved)* +- **`HAS_PROPERTY` edge type** — split from `HAS_METHOD` to distinguish property linkage +- **`declaredType` field** on Property symbols — semantic split from `returnType` (methods) +- **`resolveFieldAccessType`** in call-processor — resolves field access chains at call sites +- **`extractPropertyDeclaredType`** in shared utils — 5-strategy cross-language type extraction +- **Per-language `@definition.property` captures** — see coverage table below +- **`extractMixedChain`** in utils — unified recursive AST walker that handles both `call_expression` and `field_expression` nodes interchangeably, building `MixedChainStep[]` capped at `MAX_CHAIN_DEPTH` (3). Replaces the earlier separate `extractFieldChain` / `extractCallChain` functions. +- **`receiverMixedChain`** on `ExtractedCall` — unified chain representation replacing the old `receiverCallChain` + `receiverFieldAccess` split +- **`ACCESSES` edge type** — read and write field/property access tracking. Read edges emitted via `walkMixedChain` chain resolution; write edges emitted via tree-sitter `@assignment` capture patterns across 12 languages (C excluded). PHP includes static property writes (`ClassName::$field`). Ruby compound assignment (`operator_assignment`) tracked. +- **Unified chain resolution** in call-processor — a single loop in both `processCalls` (sequential) and `processCallsFromExtracted` (worker) walks `MixedChainStep[]`, dispatching `kind: 'field'` to `resolveFieldAccessType` and `kind: 'call'` to `resolveCallTarget` + return type extraction +- **Type-preserving stdlib passthrough** — `unwrap()`, `expect()`, `clone()`, `as_ref()`, and similar stdlib methods that don't change the receiver type are recognized as identity operations in the chain loop, allowing chains like `user.unwrap().save()` to resolve correctly when TypeEnv has already stripped the nullable wrapper +- **C++ `field_declaration`** property capture via `field_identifier` declarator +- **C++ `field_expression` support** — tree-sitter-cpp uses `argument` (not `object`) for the receiver of `field_expression`; `extractMixedChain` handles this +- **C++ inline method double-indexing guard** — prevents `@definition.function` from creating duplicate symbol entries for methods already captured by `@definition.method` inside class/struct bodies (applied in both `parsing-processor.ts` and `parse-worker.ts`) +- **Rust unit struct instantiation** — `let svc = UserService;` (bare identifier assignment) now recognized by type-env when the RHS matches a known class/struct name +- **Ruby YARD `@return [Type]`** extraction for `attr_accessor` properties, enabling field-type resolution in dynamically typed Ruby + +#### Language coverage + +| Language | Property capture | `declaredType` extraction | Deep chain | Notes | +|----------|-----------------|--------------------------|:----------:|-------| +| TypeScript | ✅ `public_field_definition`, `private_property_identifier`, `required_parameter` | ✅ Strategy 2 (type_annotation) | ✅ | Parameter properties added | +| JavaScript | ✅ `field_definition` | ⚠️ No type annotations in JS | — | Capture added; declaredType requires JSDoc | +| Java | ✅ `field_declaration` | ✅ Strategy 3 (parent type) | ✅ | | +| C# | ✅ `property_declaration` | ✅ Strategy 1 (type field) | ✅ | | +| Go | ✅ `field_declaration` | ✅ Strategy 1 (type field) | ✅ | | +| Kotlin | ✅ `property_declaration` | ✅ Strategy 4 (variable_declaration) | ✅ | New strategy added | +| PHP | ✅ `property_declaration` | ✅ Strategy 1 + PHPDoc @var fallback | ✅ | Strategy 5 for pre-7.4 | +| Rust | ✅ `field_declaration` | ✅ Strategy 1 (type field) | ✅ | `extractMemberAccessParts` handles `field_expression` via `value`/`field` | +| Python | ✅ `assignment` with `type` | ✅ Class-level annotations | ✅ | `self.x` instance pattern not yet supported | +| Ruby | ✅ `attr_*` via call routing | ✅ YARD `@return [Type]` | — | YARD fallback for dynamically typed properties | +| C++ | ✅ `field_declaration` via `field_identifier` | ✅ Strategy 1 (type field) | ✅ | | +| Swift | ✅ `property_declaration` | ⚠️ Untested | — | | + +#### What remains open + +- **8C. Pattern destructuring** dependent on field knowledge +- Python `self.x` instance attribute pattern + +### Problems this phase addresses + +#### 8A. Deep property chains *(delivered)* + +```typescript +user.address.city.getName() +``` + +✅ `extractFieldChain` recursively walks nested member_expression nodes at parse time, building a `fieldChain: string[]`. At resolution time, the chain is walked step-by-step: `user → User`, `address → Address`, `city → City`, `getName() → City#getName`. Supported across TS, Java, C#, Go, Kotlin, PHP, C++. + +#### 8B. Mixed field+method chain resolution *(delivered)* + +```typescript +svc.getUser().address.save() // call → field → call +user.getAddress().city.getName() // call → field → call +user.address.getCity().save() // field → call → call +user.unwrap().save() // stdlib passthrough → call +``` + +✅ `extractMixedChain` walks both call-expression and field-expression nodes in a single unified pass, producing `MixedChainStep[]`. The resolver walks steps left-to-right: `kind: 'field'` resolves via `resolveFieldAccessType`, `kind: 'call'` resolves via `resolveCallTarget` + return type extraction. Stdlib passthroughs (`unwrap`, `clone`, `expect`, etc.) are recognized as type-preserving identity operations. + +#### 8C. Pattern destructuring that depends on field knowledge + +This is especially relevant for: + +- Rust struct-pattern destructuring +- PHP chained property access +- richer TypeScript or Python object-based destructuring in future work + +### Engineering direction (as implemented) + +- ~~parse field / property declarations per class or struct~~ ✅ +- ~~build a field-type map keyed by owning type~~ ✅ (`fieldByOwner` index) +- ~~teach lookup and chain-resolution logic to walk member segments (deep chains)~~ ✅ (`extractMixedChain` + unified chain-walking loop) +- ~~unify field chains and call chains into a single representation~~ ✅ (`MixedChainStep[]` replaces separate `receiverCallChain` / `receiverFieldAccess`) +- ~~C++ struct member field capture~~ ✅ (`field_declaration` via `field_identifier`) +- ~~C++ `field_expression` receiver extraction~~ ✅ (`argument` field support in `extractMixedChain`) +- ~~Rust unit struct instantiation~~ ✅ (`let svc = TypeName;` recognized by type-env) +- ~~Ruby YARD `@return` for `attr_accessor`~~ ✅ (comment-walking in `call-routing.ts`) +- ~~stdlib passthrough methods~~ ✅ (`TYPE_PRESERVING_METHODS` set in call-processor) +- keep this separate from the base variable-binding layer where possible + +### Delivered impact + +This is the biggest unlock for richer static analysis because it allows the graph to model more than just top-level receivers. + +It materially improved: + +- chained property resolution (up to 3 levels deep) +- mixed field+method chain resolution (e.g. `svc.getUser().address.save()`) +- member-based call disambiguation across 9 languages +- deeper context extraction for downstream tooling +- C++ struct/class field visibility in the knowledge graph +- C++ chained method call resolution (previously blocked by missing `argument` field support) +- Rust nullable receiver chains (`user.unwrap().save()`) +- Ruby field-type resolution via YARD documentation + +### Risk level + +**High** (delivered — risk was managed through incremental delivery across 8, 8A, 8B) + +This phase pushed the system from variable typing into structural object modelling. Remaining work: + +- careful handling of inheritance / embedding / language-specific member semantics +- pattern destructuring dependent on field knowledge (8C) + +--- + +## Phase 9: Full Return-Type-Aware Variable Binding + +### Goal + +Make return-type-driven inference a first-class input to `TypeEnv`, not just a downstream verification path. + +### Problems this phase addresses + +#### 9A. Binding variables from call results + +```typescript +const users = repo.getUsers() +``` + +Desired binding: + +- `users -> List<User>` + +#### 9B. Looping directly over call results + +```typescript +for (const user of getUsers()) { + user.save() +} +``` + +Desired binding: + +- `user -> User` + +#### 9C. Broader method-chain inference + +```typescript +repo.getUsers().first() +``` + +If return types can propagate more systematically, later chain stages become much more resolvable. + +### Engineering direction + +- expose return types as reusable inference inputs inside `TypeEnv` +- distinguish raw textual return types from normalized receiver-usable types +- make method-call return inference receiver-aware where necessary +- avoid over-eager propagation when multiple call targets remain ambiguous + +### Expected impact + +This phase would make the type system feel much closer to a static-analysis substrate rather than a set of local heuristics. + +It will especially improve codebases that rely heavily on: + +- service-returned collections +- builder APIs +- repository methods +- chain-heavy fluent interfaces + +### Risk level + +**Medium to High** + +The conceptual basis already exists, but generalising it without introducing false bindings requires careful ambiguity rules. + +--- + +## Language-Specific Gaps + +### Swift + +Current support remains relatively minimal. + +Missing or weak areas include: + +- for-loop element binding +- pattern binding +- assignment-chain propagation +- broader expression-based inference + +**Priority:** Medium +**Reason:** It matters for parity, but the biggest global analysis gains are elsewhere. + +### Go + +Key remaining gaps: + +- ~~iterable call expressions in range loops~~ ✓ shipped in Phase 7.3 +- `obj.field++` / `obj.field--` produce `inc_statement`/`dec_statement` nodes (not `assignment_statement`), so write ACCESSES edges are not emitted for increment/decrement on struct fields + +**Priority:** Medium (chained property access remains for Phase 8) + +### PHP + +Key remaining gaps: + +- ~~file/class-scope iterable propagation~~ ✓ shipped in Phase 7.4 (Strategy C) +- chained property access + +**Priority:** High +**Reason:** PHP heavily benefits from doc-comment-aware field and property modelling. + +### Rust + +Key remaining gap: + +- struct-pattern field destructuring + +**Priority:** Medium +**Reason:** Important for completeness, but field-type infrastructure is the real prerequisite. + +### All languages + +Shared missing capabilities: + +- ~~field / property type resolution~~ ✓ shipped in Phase 8 + 8A (10 languages) +- ~~mixed field+method chain resolution~~ ✓ shipped in Phase 8B (unified `MixedChainStep[]`) +- generalised return-type-aware binding in `TypeEnv` (Phase 9) + +**Priority:** High +**Reason:** Return-type propagation is the biggest remaining blocker to deeper static analysis. + +--- + +## Recommended Delivery Order + +### ~~1. Generalise existing return and loop inference~~ ✅ Phase 7 + +Delivered. Iterable call-expression support, `ReturnTypeLookup`, file-scope binding, PHP Strategy C. + +### ~~2. Add field / property type maps~~ ✅ Phase 8 + 8A + 8B + +Delivered. Per-type field metadata, deep chain resolution (up to 3 levels), mixed field+method chains, type-preserving stdlib passthrough, C++ and Rust fixes. + +### 3. Promote return types into first-class `TypeEnv` inputs ← **next** + +This converts existing downstream validation into a broader inference capability. + +Deliverables: + +- call-result variable binding (`var x = f()` propagation) +- loop inference from call results (already done for direct iterables, pending for assigned results) +- broader chain propagation + +### 4. Broaden branch-sensitive narrowing where low-risk + +After the structural work lands, selective branch refinement becomes more valuable and easier to reason about. + +--- + +## What “Production-Grade Static Analysis” Means Here + +For GitNexus, production-grade does **not** mean replacing a language compiler. + +A realistic target is: + +- strong receiver-constrained call resolution across common language idioms +- reliable handling of typed loops, constructor-like initializers, and common patterns +- useful return-type propagation for service/repository style code +- enough field/property knowledge to support chained-member analysis +- conservative behavior under ambiguity +- predictable performance during indexing + +That would be sufficient for: + +- better call graphs +- more accurate impact analysis +- stronger context assembly for AI workflows +- more trustworthy graph traversal features + +--- + +## Suggested Milestone Definitions + +### Milestone A — Inference Expansion ✅ + +Delivered in Phase 7. + +- loop inference works for identifier iterables and common call-expression iterables across 7 languages +- `ReturnTypeLookup` threads return-type knowledge into TypeEnv +- PHP class-level `@var` property typing for `$this->property` foreach + +### Milestone B — Structural Member Typing ✅ + +Delivered in Phase 8 + 8A + 8B. + +- field/property maps exist for class-like types across 9 languages +- deep chains resolve up to 3 levels (`user.address.city.getName()`) +- mixed field+method chains resolve interleaved patterns (`svc.getUser().address.save()`) +- stdlib passthroughs (`unwrap`, `clone`, etc.) are type-preserving in chains +- C++ and Rust chain call resolution fixed (field_expression argument, unit struct) + +### Milestone C — Static-Analysis Foundation ← **next** + +Success looks like: + +- return-type-aware variable binding is a first-class part of environment construction +- chains, loops, and assignments share a coherent propagation model +- downstream graph features can rely on more than local receiver heuristics + +--- + +## Open Questions for Future Design + +These should be resolved before or during implementation of the later phases. + +1. **Where should field-type metadata live?** + ✅ Resolved: in `SymbolTable` via the `fieldByOwner` index, keyed by `ownerNodeId\0fieldName`. Properties live alongside other symbols but are excluded from `globalIndex` to prevent namespace pollution. + +2. **How should ambiguity be represented?** + Is `undefined` sufficient, or do later phases need a richer "known ambiguous" state? + +3. **How much receiver context should return-type inference require?** + Some methods only become meaningful once the receiver type is already partially known. + +4. **How much branch sensitivity is worth the complexity?** + Some narrowing gives clear value; full control-flow typing likely does not. + +5. **Should field typing and chain typing be one phase or two?** + ✅ Resolved: delivered as Phase 8 (single-level) + Phase 8A (deep chains) in the same branch, with separate test suites per language. Incremental delivery within one phase worked well. + +--- + +## Summary + +Phases 7 and 8 (including 8A and 8B) are **complete**. The type system now handles: + +- ✅ explicit type annotations and parameters across 13 languages +- ✅ initializer/constructor inference with SymbolTable validation +- ✅ loop element inference including call-expression iterables (7 languages) +- ✅ field/property type resolution with deep chains (up to 3 levels, 10 languages) +- ✅ mixed field+method chains (`svc.getUser().address.save()`) +- ✅ type-preserving stdlib passthroughs (`unwrap`, `clone`, `expect`, etc.) +- ✅ comment-based types (JSDoc, PHPDoc, YARD) + +**The next step is Phase 9**: promote return-type-aware inference into `TypeEnv` as a first-class input, enabling `var x = f()` variable binding and broader chain propagation. The `pendingCallResults` infrastructure is already in place (Tier 2b loop + `PendingAssignment` union) — it just needs extractors to emit `{ kind: 'callResult' }` entries. + +That path preserves the current strengths of the system while moving GitNexus the final step toward a robust, production-grade static-analysis foundation. diff --git a/type-resolution-system.md b/type-resolution-system.md new file mode 100644 index 0000000000..9f2357e41c --- /dev/null +++ b/type-resolution-system.md @@ -0,0 +1,442 @@ +# Type Resolution System + +GitNexus's type resolution system maps variables to likely declared types across the supported languages so the ingestion pipeline can perform **receiver-constrained call resolution**. + +When the code contains a call such as `user.save()`, the resolver tries to determine that `user` is a `User`, allowing call resolution to prefer `User#save` over unrelated methods such as `Repo#save`. + +This system is designed to be: + +- **Conservative** — it prefers missing a binding over introducing a misleading one +- **Single-pass** — bindings are collected during a single AST walk, with a limited post-pass for assignment propagation +- **Scope-aware** — function-local bindings are isolated from file-level bindings +- **Per-file** — the environment is built for one file at a time, though it may consult the global `SymbolTable` for validation in specific cases + +It is **not** a full compiler type checker. Its job is to recover enough type information to improve call-edge accuracy during ingestion. + +--- + +## Purpose in the Pipeline + +Type resolution sits between parsing and call resolution. + +```text +parse-worker.ts + │ + ▼ +buildTypeEnv(tree, language, symbolTable?) + │ + ├──► TypeEnvironment.lookup(varName, callNode) + │ │ + │ ▼ + │ call-processor.ts + │ - resolves receiver type for method calls + │ - filters candidates by receiver match + │ - verifies deferred constructor / initializer bindings + │ + └──► discarded after file processing +``` + +The `TypeEnvironment` is built once per file. `call-processor.ts` then uses `lookup()` to determine receiver types and narrow candidate symbols from the `SymbolTable`. + +--- + +## Architecture + +```text + ┌──────────────────────┐ + │ type-env.ts │ + │ │ + │ buildTypeEnv() │ + │ - Single AST walk │ + │ - Scope tracking │ + │ - Tier orchestration│ + └──────────┬───────────┘ + │ dispatches to + ┌───────────────────────┬┴┬────────────────────────┐ + │ │ │ │ + ┌─────────▼──────────┐ ┌─────────▼─▼─────────┐ ┌──────────▼─────────┐ + │ shared.ts │ │ <language>.ts │ │ types.ts │ + │ │ │ │ │ │ + │ Container table │ │ Per-language │ │ Extractor │ + │ Type helpers │ │ extractors │ │ interface defs │ + │ Generic helpers │ │ (shared + per-lang) │ │ │ + └────────────────────┘ └──────────────────────┘ └────────────────────┘ +``` + +### Main files + +| File | Purpose | +|------|---------| +| `type-env.ts` | Core engine. Walks the AST once, tracks scopes, collects bindings, and exposes `buildTypeEnv()` plus the `TypeEnvironment` interface. | +| `types.ts` | TypeScript interfaces for extractor hooks such as `TypeBindingExtractor`, `ForLoopExtractor`, and `PatternBindingExtractor`. | +| `shared.ts` | Language-agnostic helpers such as `extractSimpleTypeName`, `extractElementTypeFromString`, `resolveIterableElementType`, `CONTAINER_DESCRIPTORS`, and `TYPED_PARAMETER_TYPES`. | +| `index.ts` | Dispatch map from `SupportedLanguages` to `LanguageTypeConfig`. | +| `typescript.ts` | TypeScript and JavaScript extractors, including JSDoc support. | +| `jvm.ts` | Java and Kotlin extractors. | +| `csharp.ts` | C# extractors. | +| `go.ts` | Go extractors, including range semantics. | +| `rust.ts` | Rust extractors, including `if let`, match-related handling, and `Self` resolution. | +| `python.ts` | Python extractors, including `match` / `case` handling. | +| `php.ts` | PHP extractors, including PHPDoc support. | +| `ruby.ts` | Ruby extractors, including YARD support. | +| `swift.ts` | Swift extractors. Currently the most minimal configuration. | +| `c-cpp.ts` | Shared C / C++ extractors. | + +--- + +## Supported Languages + +The current type-resolution layer supports **13 languages**: + +- TypeScript +- JavaScript +- Python +- Java +- Kotlin +- C# +- Go +- Rust +- PHP +- Ruby +- Swift +- C +- C++ + +Not all languages have the same level of coverage. Swift remains the most minimal. C and some C++ cases naturally benefit less from receiver typing than object-oriented languages. + +--- + +## Design Constraints + +The type resolution layer is intentionally narrower than a compiler-grade type system. + +It does: + +- resolve variable types from declarations, parameters, initializers, loops, and selected pattern constructs +- normalize common wrappers such as nullable types and generic containers +- improve receiver matching during call resolution +- verify some ambiguous initializer bindings against the `SymbolTable` + +It does not: + +- perform full semantic type checking +- run fixpoint inference +- propagate inferred bindings across files as ordinary environment entries +- guarantee resolution for every ambiguous construct + +--- + +## TypeEnvironment Model + +`buildTypeEnv()` returns a `TypeEnvironment` that contains: + +- scoped bindings collected from the current file +- deferred constructor / initializer binding candidates +- lookup helpers used by call resolution +- pattern override data for branch-local narrowing where supported + +### Scope model + +The environment is scope-aware so identical variable names in different functions do not collide. + +```text +File scope ('') +├── config → Config +├── users → Map +│ +├── processUsers@100 +│ ├── user → User +│ └── alias → User +│ +└── processRepos@200 + └── repo → Repo +``` + +### Scope keys + +- `''` for file scope +- `functionName@startIndex` for function-local scope + +These scope keys are also used later when verifying deferred bindings in call processing, so any future change to scope-key format must stay consistent across both layers. + +--- + +## Lookup Semantics + +`TypeEnvironment.lookup()` resolves types in this effective order: + +1. special receivers + - `this`, `self`, `$this` → enclosing class + - `super`, `base`, `parent` → parent class +2. position-indexed pattern overrides +3. function-local scope +4. file-level scope + +Special receivers are handled as a dedicated fast path rather than ordinary lexical bindings. + +--- + +## Resolution Tiers + +Bindings are collected during the same AST walk. Higher-confidence sources win over weaker inference. + +### Tier 0: Explicit Type Annotations + +Direct extraction from AST type nodes. + +```typescript +// TypeScript +const user: User = getUser() + +// Java +User user = getUser() + +// Go +var user User + +// Rust +let user: User = get_user() + +// Python +user: User = get_user() +``` + +`extractDeclaration()` reads the declaration type node and normalizes it through `extractSimpleTypeName()`. + +Parameters are handled separately by `extractParameter()` using the same normalization logic. The shared `TYPED_PARAMETER_TYPES` set controls which AST node types are treated as typed parameters. + +### Tier 0b: For-Loop Element Type Resolution + +Also referred to as **Tier 1c** in Phase 6 PR and test naming. + +For-each style loops often introduce a variable with no explicit type. In those cases, the resolver derives the loop variable type from the iterable's container type. + +```csharp +foreach (var user in users) { user.Save(); } + +// TypeScript +for (const user of users) { user.save(); } + +// Rust +for user in users { user.save(); } +``` + +This is handled by `resolveIterableElementType()` through a three-step cascade: + +1. **Declaration type nodes** + Uses raw type annotation nodes when available, including cases such as `User[]` or `List[User]`. + +2. **Scope environment string** + Uses `extractElementTypeFromString()` to parse a stored type string. + +3. **AST walk fallback** + Walks upward to enclosing declarations or parameters when needed. + +### Tier 0c: Pattern Binding + +Pattern-matching constructs may introduce a new variable or temporarily narrow an existing one. + +```csharp +if (obj is User user) { user.Save(); } + +// Java +if (obj instanceof User user) { user.save(); } + +// Rust +if let Some(user) = opt { user.save(); } + +// Python +match obj: + case User() as user: + user.save() +``` + +Binding behavior depends on the language: + +- **first-writer-wins** is used by default +- **position-indexed branch overrides** are used where branch-local narrowing must not leak between branches, most notably Kotlin + +### Tier 1: Initializer / Constructor Inference + +When there is no explicit annotation, the resolver can infer a type from the initializer. + +```typescript +const user = new User() + +// C# +var user = new User() + +// Kotlin +val user = User() + +// Go +user := User{} +ptr := &User{} +user2 := new(User) + +// Ruby +user = User.new +``` + +Some languages can identify constructor-like syntax directly. Others need validation through the `SymbolTable`, because syntax alone cannot always distinguish `User()` from `getUser()`. + +In those cases the system records an unverified binding candidate and later validates it against known class / struct symbols. + +### Tier 2: Assignment Chain Propagation + +Bindings can propagate through simple identifier assignments. + +```typescript +const user: User = getUser() +const alias = user +const other = alias +``` + +This is handled after the main walk through a single pass over pending assignments. + +This supports simple forward propagation, but there is no iterative fixpoint step. For example: + +```typescript +const b = a +const a: User = getUser() +``` + +will not resolve `b`. + +--- + +## Container Type Descriptors + +`CONTAINER_DESCRIPTORS` defines the type-parameter semantics for common containers. + +That allows the resolver to distinguish key-yielding methods from value-yielding methods instead of always assuming the last generic argument. + +```typescript +for (const key of map.keys()) { ... } // key → string +for (const val of map.values()) { ... } // val → User +``` + +Unknown containers fall back to heuristics, keeping the system conservative rather than fully semantic. + +### Examples of descriptor-driven behavior + +- `Map<K, V>` / `Dictionary<K, V>` / similar key-value containers +- `List<T>` / `Array<T>` / `Vec<T>` / `Set<T>` / similar single-element containers +- method-aware yield selection such as `.keys()`, `.values()`, `.keySet()`, `.Values` + +--- + +## Comment-Based Types + +For less strictly typed ecosystems, the resolver can fall back to documentation-based type information. + +Supported comment systems: + +- **JSDoc** for JavaScript / TypeScript +- **PHPDoc** for PHP +- **YARD** for Ruby + +These are used conservatively and only when AST-level type information is missing or insufficient. + +--- + +## SymbolTable Interaction + +Although the environment is built per file, it may consult the global `SymbolTable` in specific validation paths. + +This is important for languages where constructor-like syntax is ambiguous. A binding candidate such as `val user = User()` may need confirmation that `User` is a class-like symbol rather than an ordinary function. + +This means the system is still **per-file in binding construction**, but not completely isolated from project-wide symbol knowledge. + +--- + +## Deferred Binding Verification in Call Processing + +A key detail is that some initializer bindings are not fully resolved inside `TypeEnv` itself. + +`call-processor.ts` later verifies deferred bindings and may infer receiver types from: + +- validated class / struct constructor candidates +- uniquely resolved function or method calls that expose a usable return type + +So return-type-aware receiver inference already exists in a constrained downstream form today. Phase 7.3 extended this by threading `ReturnTypeLookup` into `TypeEnv` via `ForLoopExtractorContext`, enabling for-loop call-expression iterables (e.g., `for (const u of getUsers())`) to resolve element types in 7 languages (TS/JS, Java, Kotlin, C#, Go, Rust, Python, PHP). General assignment propagation (`var x = f()` binding the return type of `f` into the scope env) remains pending — the `pendingCallResults` infrastructure exists but is dormant until Phase 9. + +--- + +## Language Feature Matrix + +| Feature | TS | JS | Java | Kotlin | C# | Go | Rust | Python | PHP | Ruby | Swift | C++ | C | +|---------|:--:|:--:|:----:|:------:|:--:|:--:|:----:|:------:|:---:|:----:|:-----:|:---:|:-:| +| Declarations | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | +| Parameters | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | +| Initializer / constructor inference | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | +| Constructor binding scan | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | +| For-loop element types | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No | Yes | Yes | +| Pattern binding | Yes | Yes | Yes | Yes | No | Yes | Yes | No | No | No | No | No | No | +| Assignment chains | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes | +| Field/property type resolution | Yes | No† | Yes | Yes | Yes | Yes | Yes | Yes* | Yes | YARD | No | Yes | No‡ | +| Comment-based types | JSDoc | JSDoc | No | No | No | No | No | No | PHPDoc | YARD | No | No | No | +| Return type extraction | JSDoc | JSDoc | No | No | No | No | No | No | PHPDoc | YARD | No | No | No | +| Write access (ACCESSES write) | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes§ | Yes | Yes | Yes | No | + +\* Python class-level annotated attributes (`address: Address`) now resolve `declaredType` correctly. The `self.x` instance attribute pattern is not yet supported. + +† JS field topology is captured (`field_definition` → `HAS_PROPERTY` edges) but `declaredType` is never set — JS has no AST type annotations. Disambiguation via `lookupFieldByOwner` requires `declaredType`. JSDoc `@type` support is a Phase 9 candidate. + +‡ C has no `@definition.property` query pattern. Struct member fields are not captured. C++ captures class/struct member fields via `field_declaration`. + +§ PHP write access covers instance property writes (`$obj->field = value`) and static property writes (`ClassName::$field = value`). Nullsafe writes (`$obj?->field = value`) are not tracked because this is invalid PHP syntax — null-safe member access on the left-hand side of assignment is a parse error. + +--- + +## Current Strengths + +The current system provides strong value for call resolution because it combines: + +- explicit annotation extraction across 13 languages +- generic-aware loop element typing (including call-expression iterables) +- initializer-based inference with SymbolTable validation +- selected pattern-based narrowing +- scope-aware lookups +- comment-based fallbacks for dynamic ecosystems (JSDoc, PHPDoc, YARD) +- constrained return-type-aware receiver inference in call processing +- deep field/property chains up to 3 levels across 9 languages +- ACCESSES edge emission for field read access (via chain walking) and field write access (via assignment capture) across 12 languages +- mixed field+method chain resolution (e.g. `svc.getUser().address.save()`) +- type-preserving stdlib passthrough for `unwrap()`, `clone()`, `expect()`, etc. + +This is enough to materially improve call-edge precision even without implementing a full static type system. + +--- + +## Current Limitations + +Important gaps still remain: + +- no general cross-file propagation of inferred bindings +- no fixpoint inference +- limited branch-sensitive narrowing outside selected pattern constructs +- limited Swift support compared with other languages +- no complete destructuring-based field typing +- no broad expression-level return-type propagation inside `TypeEnv` (for-loop call-expression iterables are resolved in 7 languages via `ReturnTypeLookup`, but general `var x = f()` assignment propagation is pending) + +--- + +## Contributor Notes + +When modifying this system, treat the following as load-bearing invariants: + +1. **Conservatism matters more than recall** + A missed binding is usually safer than a misleading receiver type. + +2. **Scope-key format is shared behavior** + If scope keys change, constructor-binding verification and any downstream lookup using those keys must change in sync. + +3. **Tier naming may differ across code and PR discussions** + For-loop element inference may appear as "Tier 0b" in documentation and "Tier 1c" in Phase 6 PR / test naming. + +4. **Comment-based types are fallback signals, not primary truth** + They should remain lower-trust than explicit AST-derived types. + +5. **Return-type-aware inference already exists in constrained form** + Future roadmap work should extend and generalize it rather than reintroduce it from scratch.