feat: tsconfig/jsconfig discovery, tolerant JSONC parser, paths alias resolution (issue-3, PR 1/3)

Author: NehharShah

src/repokg/deps.py

@@ -5,6 +5,7 @@
 """
 
 import ast
+import json
 import os
 import re
 from collections import Counter
@@ -16,9 +17,12 @@
 GO_QUOTED_RE = re.compile(r'"([^"]+)"')
 GO_MODULE_RE = re.compile(r"^module\s+(\S+)", re.M)
 JS_IMPORT_RE = re.compile(
-    r"""(?:from\s+|require\(\s*|import\(\s*|^\s*import\s+)['"](\.{1,2}/[^'"]+)['"]""",
+    r"""(?:from\s+|require\(\s*|import\(\s*|^\s*import\s+)['"]([^'"]+)['"]""",
     re.M)
 JS_EXTS = (".ts", ".tsx", ".js", ".jsx", ".mjs")
+# tsconfig wins over jsconfig when a dir carries both (jsconfig is the
+# JS-only subset of the same format).
+JS_CONFIG_FILES = ("tsconfig.json", "jsconfig.json")
 # [package] section of a Cargo.toml, up to the next table header.
 CARGO_PACKAGE_RE = re.compile(r"^\[package\]\s*$(.*?)(?=^\[|\Z)", re.M | re.S)
 CARGO_NAME_RE = re.compile(r'^\s*name\s*=\s*"([^"]+)"', re.M)
@@ -162,16 +166,154 @@ def _py_edge(rel, module, level, pkg_map, dirs, counter):
 # -- JS / TS -----------------------------------------------------------------
 
 def _js_edges(repo, tree, dirs, counter):
+    """Relative imports resolve directly; non-relative specifiers go through
+    the nearest tsconfig/jsconfig's `paths` aliases and `baseUrl` (bare
+    third-party imports match nothing there and drop out)."""
+    configs = _js_configs(repo, tree)
     for rel, files in tree.items():
+        cfg = _owning_root(rel, configs) if configs else None
         for f in files:
             if not f.endswith(JS_EXTS) or f.endswith(".d.ts"):
                 continue
             for imp in JS_IMPORT_RE.findall(_read(repo, rel, f)):
-                target = _existing_dir(_norm(os.path.join(rel, imp)), dirs)
+                if imp.startswith("."):
+                    target = _existing_dir(_norm(os.path.join(rel, imp)), dirs)
+                elif cfg is not None and not imp.startswith("/"):
+                    target = _js_alias_resolve(imp, configs[cfg], dirs)
+                else:
+                    target = None
                 if target is not None and target != rel:
                     counter[(rel, target, "JS/TS")] += 1
 
 
+def _js_configs(repo, tree):
+    """{config dir: (paths_base, patterns, bare_base)} from tsconfig/jsconfig.
+
+    paths_base: dir that `paths` values resolve against — baseUrl when set,
+    else the config's own dir (TS 4.4 semantics). patterns: (pattern, values)
+    sorted most-specific-first (longest literal prefix before `*`), matching
+    tsconfig's own tie-break. bare_base: baseUrl dir when explicitly set —
+    bare specifiers additionally resolve against it, after `paths`.
+    Configs defining neither baseUrl nor paths are skipped so an
+    extends-only leaf config does not shadow the root's aliases
+    (`extends` chains themselves are not followed).
+    """
+    configs = {}
+    for rel, files in tree.items():
+        name = next((c for c in JS_CONFIG_FILES if c in files), None)
+        if name is None:
+            continue
+        data = _jsonc_loads(_read(repo, rel, name))
+        opts = data.get("compilerOptions") if isinstance(data, dict) else None
+        if not isinstance(opts, dict):
+            continue
+        base = opts.get("baseUrl")
+        bare_base = _norm(os.path.join(rel, base)) if isinstance(base, str) else None
+        patterns = []
+        paths = opts.get("paths")
+        if isinstance(paths, dict):
+            for pat, vals in paths.items():
+                if not isinstance(pat, str) or not isinstance(vals, list):
+                    continue
+                vals = [v for v in vals if isinstance(v, str)]
+                if vals:
+                    patterns.append((pat, vals))
+        patterns.sort(  # exact patterns beat wildcards; longer prefix wins
+            key=lambda pv: ("*" in pv[0], -pv[0].find("*"), pv[0]))
+        if bare_base is None and not patterns:
+            continue
+        configs[rel] = (bare_base if bare_base is not None else rel,
+                        patterns, bare_base)
+    return configs
+
+
+def _js_alias_resolve(imp, cfg, dirs):
+    """Resolve a non-relative specifier through `paths` patterns (first
+    existing substitution wins), then baseUrl-relative lookup; None when
+    nothing grounds in the repo tree."""
+    paths_base, patterns, bare_base = cfg
+    for pat, vals in patterns:
+        star = pat.find("*")
+        if star == -1:
+            if imp != pat:
+                continue
+            stem = ""
+        else:
+            pre, suf = pat[:star], pat[star + 1:]
+            if not (len(imp) >= len(pre) + len(suf)
+                    and imp.startswith(pre) and imp.endswith(suf)):
+                continue
+            stem = imp[len(pre):len(imp) - len(suf)]
+        for val in vals:
+            target = _existing_dir(
+                _norm(os.path.join(paths_base, val.replace("*", stem, 1))),
+                dirs)
+            if target is not None:
+                return target
+    if bare_base is not None:
+        return _existing_dir(_norm(os.path.join(bare_base, imp)), dirs)
+    return None
+
+
+def _jsonc_loads(text):
+    """json.loads for the JSONC dialect tsconfig uses: // and /* */ comments
+    and trailing commas are stripped (string-aware, so comment-lookalikes
+    inside string values survive). Returns None when still not valid JSON."""
+    out, i, n = [], 0, len(text)
+    while i < n:  # pass 1: strip comments
+        c = text[i]
+        if c == '"':
+            j = _jsonc_string_end(text, i)
+            out.append(text[i:j])
+            i = j
+        elif text[i:i + 2] == "//":
+            while i < n and text[i] != "\n":
+                i += 1
+        elif text[i:i + 2] == "/*":
+            end = text.find("*/", i + 2)
+            i = n if end == -1 else end + 2
+        else:
+            out.append(c)
+            i += 1
+    text = "".join(out)
+    out, i, n = [], 0, len(text)
+    while i < n:  # pass 2: drop trailing commas
+        c = text[i]
+        if c == '"':
+            j = _jsonc_string_end(text, i)
+            out.append(text[i:j])
+            i = j
+        elif c == ",":
+            j = i + 1
+            while j < n and text[j] in " \t\r\n":
+                j += 1
+            if j < n and text[j] in "}]":
+                i += 1  # trailing comma: skip it
+            else:
+                out.append(c)
+                i += 1
+        else:
+            out.append(c)
+            i += 1
+    try:
+        return json.loads("".join(out))
+    except ValueError:
+        return None
+
+
+def _jsonc_string_end(text, i):
+    """Index just past the string literal opening at text[i]."""
+    j, n = i + 1, len(text)
+    while j < n:
+        if text[j] == "\\":
+            j += 2
+        elif text[j] == '"':
+            return j + 1
+        else:
+            j += 1
+    return n
+
+
 # -- Rust --------------------------------------------------------------------
 
 def _rust_edges(repo, tree, counter):

tests/test_deps_js.py

@@ -0,0 +1,198 @@
+import os
+import tempfile
+import unittest
+
+from repokg.code import walk
+from repokg.deps import _js_configs, _jsonc_loads, collect
+
+
+def write(root, rel, text):
+    path = os.path.join(root, rel)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(text)
+
+
+class TestJsoncLoads(unittest.TestCase):
+    def test_plain_json(self):
+        self.assertEqual(_jsonc_loads('{"a": [1, 2]}'), {"a": [1, 2]})
+
+    def test_comments_stripped(self):
+        self.assertEqual(_jsonc_loads(
+            '{\n'
+            '  // line comment\n'
+            '  "a": 1, /* block\n'
+            '  comment */ "b": 2\n'
+            '}'), {"a": 1, "b": 2})
+
+    def test_trailing_commas_stripped(self):
+        self.assertEqual(_jsonc_loads('{"a": [1, 2, ], "b": {"c": 3,},}'),
+                         {"a": [1, 2], "b": {"c": 3}})
+
+    def test_comment_lookalikes_inside_strings_survive(self):
+        self.assertEqual(_jsonc_loads(
+            '{"url": "https://x.dev", "glob": "src/**/*", "csv": "a,}"}'),
+            {"url": "https://x.dev", "glob": "src/**/*", "csv": "a,}"})
+
+    def test_escaped_quote_inside_string(self):
+        self.assertEqual(_jsonc_loads('{"a": "say \\"hi\\" // ok",}'),
+                         {"a": 'say "hi" // ok'})
+
+    def test_invalid_returns_none(self):
+        self.assertIsNone(_jsonc_loads("{not json"))
+        self.assertIsNone(_jsonc_loads(""))
+
+
+class TestJsConfigs(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.repo = self.tmp.name
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def tree(self):
+        return dict(walk(self.repo))
+
+    def test_baseurl_and_paths(self):
+        write(self.repo, "tsconfig.json",
+              '{"compilerOptions": {"baseUrl": "./src",'
+              ' "paths": {"@/*": ["./*"]}}}')
+        write(self.repo, "src/app.ts", "")
+        configs = _js_configs(self.repo, self.tree())
+        self.assertEqual(configs, {"": ("src", [("@/*", ["./*"])], "src")})
+
+    def test_paths_without_baseurl_resolve_from_config_dir(self):
+        write(self.repo, "web/tsconfig.json",
+              '{"compilerOptions": {"paths": {"@/*": ["./src/*"]}}}')
+        configs = _js_configs(self.repo, self.tree())
+        self.assertEqual(configs["web"], ("web", [("@/*", ["./src/*"])], None))
+
+    def test_jsconfig_supported_tsconfig_preferred(self):
+        write(self.repo, "a/jsconfig.json",
+              '{"compilerOptions": {"baseUrl": "."}}')
+        write(self.repo, "b/jsconfig.json",
+              '{"compilerOptions": {"baseUrl": "./x"}}')
+        write(self.repo, "b/tsconfig.json",
+              '{"compilerOptions": {"baseUrl": "./y"}}')
+        configs = _js_configs(self.repo, self.tree())
+        self.assertEqual(configs["a"], ("a", [], "a"))
+        self.assertEqual(configs["b"], ("b/y", [], "b/y"))
+
+    def test_config_without_aliases_ignored(self):
+        write(self.repo, "tsconfig.json",
+              '{"extends": "./tsconfig.base.json",'
+              ' "compilerOptions": {"strict": true}}')
+        self.assertEqual(_js_configs(self.repo, self.tree()), {})
+
+    def test_most_specific_pattern_first(self):
+        write(self.repo, "tsconfig.json",
+              '{"compilerOptions": {"paths": {'
+              '"@/*": ["./src/*"], "@/lib/*": ["./lib/*"], "@cfg": ["./cfg.ts"]}}}')
+        _, patterns, _ = _js_configs(self.repo, self.tree())[""]
+        self.assertEqual([p for p, _ in patterns], ["@cfg", "@/lib/*", "@/*"])
+
+
+class TestJsAliasEdges(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.repo = self.tmp.name
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def edges(self):
+        return {(e["from"], e["to"]): e["count"]
+                for e in collect(self.repo) if e["lang"] == "JS/TS"}
+
+    def test_alias_import_matches_equivalent_relative_import(self):
+        write(self.repo, "tsconfig.json",
+              '{"compilerOptions": {"baseUrl": ".",'
+              ' "paths": {"@/*": ["./src/*"]}}}')
+        write(self.repo, "src/components/button.tsx", "export const B = 1\n")
+        write(self.repo, "pages/index.tsx",
+              "import { B } from '@/components/button'\n"
+              "import { B as B2 } from '../src/components/button'\n")
+        self.assertEqual(self.edges(),
+                         {("pages", "src/components"): 2})
+
+    def test_bare_third_party_imports_drop(self):
+        write(self.repo, "tsconfig.json",
+              '{"compilerOptions": {"paths": {"@/*": ["./src/*"]}}}')
+        write(self.repo, "src/util.ts", "export const u = 1\n")
+        write(self.repo, "app/main.ts",
+              "import React from 'react'\n"
+              "import fs from 'node:fs'\n"
+              "const x = require('lodash/get')\n")
+        self.assertEqual(self.edges(), {})
+
+    def test_exact_alias_to_file_resolves_to_parent_dir(self):
+        write(self.repo, "tsconfig.json",
+              '{"compilerOptions": {"paths": {"@config": ["./src/config.ts"]}}}')
+        write(self.repo, "src/config.ts", "export const c = 1\n")
+        write(self.repo, "app/main.ts", "import { c } from '@config'\n")
+        self.assertEqual(self.edges(), {("app", "src"): 1})
+
+    def test_baseurl_bare_import(self):
+        write(self.repo, "jsconfig.json",
+              '{"compilerOptions": {"baseUrl": "."}}')
+        write(self.repo, "lib/util.js", "module.exports = {}\n")
+        write(self.repo, "app/main.js", "const u = require('lib/util')\n")
+        self.assertEqual(self.edges(), {("app", "lib"): 1})
+
+    def test_nearest_config_wins_and_shadows_root(self):
+        write(self.repo, "tsconfig.json",
+              '{"compilerOptions": {"paths": {"~/*": ["./shared/*"]}}}')
+        write(self.repo, "shared/log.ts", "export const l = 1\n")
+        write(self.repo, "packages/app/tsconfig.json",
+              '{"compilerOptions": {"paths": {"@/*": ["./src/*"]}}}')
+        write(self.repo, "packages/app/src/db.ts", "export const d = 1\n")
+        write(self.repo, "packages/app/main.ts",
+              "import { d } from '@/db'\n"     # nearest config's alias
+              "import { l } from '~/log'\n")   # root alias: shadowed, drops
+        write(self.repo, "tools/gen.ts",
+              "import { l } from '~/log'\n")   # root config applies here
+        self.assertEqual(self.edges(), {
+            ("packages/app", "packages/app/src"): 1,
+            ("tools", "shared"): 1,
+        })
+
+    def test_unresolved_alias_target_drops(self):
+        write(self.repo, "tsconfig.json",
+              '{"compilerOptions": {"paths": {"@/*": ["./src/*"]}}}')
+        write(self.repo, "src/a.ts", "export const a = 1\n")
+        write(self.repo, "app/main.ts", "import { g } from '@/gone/deep/x'\n")
+        self.assertEqual(self.edges(), {})
+
+    def test_first_existing_paths_value_wins(self):
+        write(self.repo, "tsconfig.json",
+              '{"compilerOptions": {"paths": {"@/*": ["./missing/*", "./src/*"]}}}')
+        write(self.repo, "src/a.ts", "export const a = 1\n")
+        write(self.repo, "app/main.ts", "import { a } from '@/a'\n")
+        self.assertEqual(self.edges(), {("app", "src"): 1})
+
+    def test_relative_imports_unchanged_without_configs(self):
+        write(self.repo, "src/a.ts", "export const a = 1\n")
+        write(self.repo, "app/main.ts",
+              "import { a } from '../src/a'\n"
+              "import missing from '@/nope'\n")
+        self.assertEqual(self.edges(), {("app", "src"): 1})
+
+    def test_jsonc_config_with_comments_and_trailing_commas(self):
+        write(self.repo, "tsconfig.json",
+              '{\n'
+              '  // aliases\n'
+              '  "compilerOptions": {\n'
+              '    "baseUrl": ".", /* root */\n'
+              '    "paths": {\n'
+              '      "@/*": ["./src/*"],\n'
+              '    },\n'
+              '  },\n'
+              '}\n')
+        write(self.repo, "src/a.ts", "export const a = 1\n")
+        write(self.repo, "app/main.ts", "import { a } from '@/a'\n")
+        self.assertEqual(self.edges(), {("app", "src"): 1})
+
+
+if __name__ == "__main__":
+    unittest.main()