@c4a/extract-ts 0.6.0-beta.4 → 0.6.0-beta.5

package/README.md

@@ -27,6 +27,11 @@ packages.
 - package kind classification: `lib`, `cli`, or `service`
 - package version propagation into `ExtractionResult.package.version`
 
+The Context project may override auto-detection with source-relative
+`extractTs.entries`, or use `mode: "scan"` to make every `include`-matched file
+an extraction root. These settings live in the Context workspace; consumers do
+not need to modify the analyzed package solely to declare extraction entries.
+
 Entry files are returned as module-relative paths. The repository runner later prefixes them to repo-relative paths in raw snapshots.
 
 ### Symbol Extraction

package/index.js

@@ -13496,7 +13496,188 @@ var UPLOAD_ALLOWED_EXTENSIONS = collectExtensions(() => true);
 var TEXT_EXTENSIONS = collectExtensions((definition) => definition.cas.encoding === "utf8");
 var UPLOAD_MAX_FILE_SIZE = 5 * 1024 * 1024;
 // src/pathUtils.ts
+import { posix as posix2 } from "node:path";
+
+// src/tsconfigPaths.ts
 import { posix } from "node:path";
+function stripJsonComments(input) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0;index < input.length; index++) {
+    const char = input[index] ?? "";
+    const next = input[index + 1] ?? "";
+    if (lineComment) {
+      if (char === `
+`) {
+        lineComment = false;
+        output += char;
+      } else {
+        output += " ";
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        output += "  ";
+        index++;
+      } else {
+        output += char === `
+` ? `
+` : " ";
+      }
+      continue;
+    }
+    if (inString) {
+      output += char;
+      if (escaped)
+        escaped = false;
+      else if (char === "\\")
+        escaped = true;
+      else if (char === '"')
+        inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      output += "  ";
+      index++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      output += "  ";
+      index++;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+function stripTrailingCommas(input) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < input.length; index++) {
+    const char = input[index] ?? "";
+    if (inString) {
+      output += char;
+      if (escaped)
+        escaped = false;
+      else if (char === "\\")
+        escaped = true;
+      else if (char === '"')
+        inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === ",") {
+      let cursor = index + 1;
+      while (/\s/u.test(input[cursor] ?? ""))
+        cursor++;
+      if (input[cursor] === "}" || input[cursor] === "]")
+        continue;
+    }
+    output += char;
+  }
+  return output;
+}
+function parseJsonConfig(raw) {
+  try {
+    const parsed = JSON.parse(stripTrailingCommas(stripJsonComments(raw)));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function normalizedPath(value) {
+  return posix.normalize(value.replace(/\\/gu, "/")).replace(/^\.\//u, "");
+}
+function pathMappings(input, baseUrl) {
+  if (input === null || typeof input !== "object" || Array.isArray(input))
+    return [];
+  const mappings = [];
+  for (const [pattern, rawTargets] of Object.entries(input)) {
+    if (!Array.isArray(rawTargets))
+      continue;
+    const wildcard = pattern.indexOf("*");
+    const targets = rawTargets.filter((target) => typeof target === "string" && target.trim().length > 0).map((target) => normalizedPath(posix.join(baseUrl, target)));
+    if (targets.length === 0)
+      continue;
+    mappings.push({
+      pattern,
+      prefix: wildcard < 0 ? pattern : pattern.slice(0, wildcard),
+      suffix: wildcard < 0 ? "" : pattern.slice(wildcard + 1),
+      targets
+    });
+  }
+  return mappings.sort((left, right) => {
+    const exactDifference = Number(!right.pattern.includes("*")) - Number(!left.pattern.includes("*"));
+    return exactDifference || right.prefix.length - left.prefix.length;
+  });
+}
+async function loadTsConfigPathResolver(fs2) {
+  const configPath = await fs2.exists("tsconfig.json") ? "tsconfig.json" : await fs2.exists("jsconfig.json") ? "jsconfig.json" : undefined;
+  return configPath === undefined ? { mappings: [] } : loadResolverFromConfig(fs2, configPath, new Set);
+}
+async function resolveExtendsPath(fs2, configPath, value) {
+  const configDir = posix.dirname(configPath);
+  const base = value.startsWith(".") ? normalizedPath(posix.join(configDir, value)) : normalizedPath(posix.join("node_modules", value));
+  const candidates = [base, `${base}.json`, posix.join(base, "tsconfig.json")];
+  for (const candidate of candidates) {
+    if (await fs2.exists(candidate))
+      return candidate;
+  }
+  return;
+}
+async function loadResolverFromConfig(fs2, configPath, seen) {
+  if (seen.has(configPath))
+    return { mappings: [] };
+  seen.add(configPath);
+  const config = parseJsonConfig(await fs2.readFile(configPath));
+  const extended = typeof config?.extends === "string" ? await resolveExtendsPath(fs2, configPath, config.extends) : undefined;
+  const parent = extended === undefined ? { mappings: [] } : await loadResolverFromConfig(fs2, extended, seen);
+  const compilerOptions = config?.compilerOptions;
+  if (compilerOptions === null || typeof compilerOptions !== "object" || Array.isArray(compilerOptions)) {
+    return parent;
+  }
+  const options = compilerOptions;
+  const configDir = posix.dirname(configPath);
+  const baseUrl = typeof options.baseUrl === "string" && options.baseUrl.trim().length > 0 ? normalizedPath(posix.join(configDir, options.baseUrl)) : parent.baseUrl;
+  const mappingBase = baseUrl ?? normalizedPath(configDir);
+  return {
+    ...baseUrl !== undefined ? { baseUrl } : {},
+    mappings: options.paths === undefined ? parent.mappings : pathMappings(options.paths, mappingBase)
+  };
+}
+function resolveTsConfigCandidates(specifier, resolver) {
+  for (const mapping of resolver.mappings) {
+    if (!mapping.pattern.includes("*")) {
+      if (specifier === mapping.pattern)
+        return mapping.targets;
+      continue;
+    }
+    if (!specifier.startsWith(mapping.prefix) || !specifier.endsWith(mapping.suffix))
+      continue;
+    const wildcard = specifier.slice(mapping.prefix.length, specifier.length - mapping.suffix.length);
+    return mapping.targets.map((target) => target.replace("*", wildcard));
+  }
+  return resolver.baseUrl === undefined ? [] : [normalizedPath(posix.join(resolver.baseUrl, specifier))];
+}
+
+// src/pathUtils.ts
 var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
 var BUILD_EXTENSIONS = [".js", ".jsx", ".mjs", ".cjs"];
 var DECLARATION_EXTENSIONS = [".d.ts", ".d.mts", ".d.cts"];
@@ -13532,12 +13713,12 @@ var BUILD_FORMAT_DIRS = new Set([
 ]);
 var unique = (items) => [...new Set(items)];
 var normalizeRelativePath = (value) => {
-  const normalized = posix.normalize(value.replace(/\\/g, "/"));
+  const normalized = posix2.normalize(value.replace(/\\/g, "/"));
   return normalized.replace(/^\.\//, "");
 };
 var stripResourceQuery = (value) => value.split(/[?#]/u)[0] ?? value;
 var hasUnsupportedExplicitExtension = (value) => {
-  const basename = posix.basename(value);
+  const basename = posix2.basename(value);
   if (!basename.includes("."))
     return false;
   return !KNOWN_CODE_SUFFIXES.some((extension) => value.endsWith(extension));
@@ -13582,7 +13763,7 @@ var createCandidatePaths = (value, options = {}) => {
     }
     for (const extension of SOURCE_EXTENSIONS) {
       candidates.add(`${base}${extension}`);
-      candidates.add(posix.join(base, `index${extension}`));
+      candidates.add(posix2.join(base, `index${extension}`));
     }
     if (BUILD_EXTENSIONS.some((extension) => normalized.endsWith(extension))) {
       for (const extension of SOURCE_EXTENSIONS) {
@@ -13600,19 +13781,28 @@ var createCandidatePaths = (value, options = {}) => {
 var isRelativeModuleSpecifier = (value) => value.startsWith("./") || value.startsWith("../");
 var resolveEntrySourcePath = async (packageDir, targetPath, fs2, options = {}) => {
   for (const candidate of createCandidatePaths(targetPath, options)) {
-    const fullPath = packageDir ? posix.join(packageDir, candidate) : candidate;
+    const fullPath = packageDir ? posix2.join(packageDir, candidate) : candidate;
     if (await fs2.exists(fullPath)) {
       return fullPath;
     }
   }
   return null;
 };
-var resolveImportSourcePath = async (fromFile, specifier, fs2) => {
-  if (!isRelativeModuleSpecifier(specifier))
+var resolveImportSourcePath = async (fromFile, specifier, fs2, resolver) => {
+  if (!isRelativeModuleSpecifier(specifier)) {
+    if (resolver === undefined)
+      return null;
+    for (const target of resolveTsConfigCandidates(specifier, resolver)) {
+      for (const candidate of createCandidatePaths(target, { allowIndexFallback: false })) {
+        if (await fs2.exists(candidate))
+          return normalizeRelativePath(candidate);
+      }
+    }
     return null;
-  const baseDir = posix.dirname(fromFile);
+  }
+  const baseDir = posix2.dirname(fromFile);
   for (const candidate of createCandidatePaths(specifier)) {
-    const fullPath = baseDir === "." ? candidate : posix.join(baseDir, candidate);
+    const fullPath = baseDir === "." ? candidate : posix2.join(baseDir, candidate);
     if (await fs2.exists(fullPath)) {
       return normalizeRelativePath(fullPath);
     }
@@ -13987,6 +14177,11 @@ var pluginSpecSchema = exports_external.object({
   package: exports_external.string().min(1),
   exportName: exports_external.string().min(1).optional()
 });
+var entrySelectionSchema = exports_external.discriminatedUnion("mode", [
+  exports_external.object({ mode: exports_external.literal("auto") }),
+  exports_external.object({ mode: exports_external.literal("configured"), entries: exports_external.array(exports_external.string().min(1)) }),
+  exports_external.object({ mode: exports_external.literal("scan") })
+]);
 var codeExtractRunnerInputSchema = exports_external.object({
   repoPath: exports_external.string().min(1),
   modules: exports_external.array(exports_external.string().min(1)).optional(),
@@ -13994,6 +14189,7 @@ var codeExtractRunnerInputSchema = exports_external.object({
   commitHash: exports_external.string().min(1).nullable().optional(),
   moduleCommits: exports_external.record(exports_external.string().nullable()).optional(),
   pathFilter: PathFilterConfigSchema.optional(),
+  entrySelection: entrySelectionSchema.optional(),
   plugins: exports_external.array(pluginSpecSchema).min(1),
   snapshot: exports_external.object({
     sourceId: exports_external.string().min(1),
@@ -14148,8 +14344,6 @@ var collectImportBindings = (root) => {
     if (!stringNode)
       continue;
     const source2 = stripQuotes(stringNode.text);
-    if (!isRelativeModuleSpecifier(source2))
-      continue;
     const clause = node2.namedChildren.find((child) => child.type === "import_clause");
     for (const part of clause?.namedChildren ?? []) {
       if (part.type === "identifier") {
@@ -14179,7 +14373,7 @@ var uniqueExports = (exportsList) => {
   });
 };
 var traceImportedBinding = async (filePath, binding, exportedName, fs2, state) => {
-  const targetPath = await resolveImportSourcePath(filePath, binding.source, fs2);
+  const targetPath = await resolveImportSourcePath(filePath, binding.source, fs2, state.resolver);
   if (!targetPath)
     return [];
   const traced = await traceFile(targetPath, fs2, state);
@@ -14233,8 +14427,8 @@ var traceFile = async (filePath, fs2, state) => {
         continue;
       }
       if (!exportClause) {
-        if (stringNode && node2.text.startsWith("export *") && isRelativeModuleSpecifier(stripQuotes(stringNode.text))) {
-          const targetPath2 = await resolveImportSourcePath(filePath, stripQuotes(stringNode.text), fs2);
+        if (stringNode && node2.text.startsWith("export *")) {
+          const targetPath2 = await resolveImportSourcePath(filePath, stripQuotes(stringNode.text), fs2, state.resolver);
           if (targetPath2) {
             exportsList.push(...await traceFile(targetPath2, fs2, state));
           }
@@ -14261,9 +14455,7 @@ var traceFile = async (filePath, fs2, state) => {
         }
         continue;
       }
-      if (!isRelativeModuleSpecifier(stripQuotes(stringNode.text)))
-        continue;
-      const targetPath = await resolveImportSourcePath(filePath, stripQuotes(stringNode.text), fs2);
+      const targetPath = await resolveImportSourcePath(filePath, stripQuotes(stringNode.text), fs2, state.resolver);
       if (!targetPath)
         continue;
       const traced = await traceFile(targetPath, fs2, state);
@@ -14287,11 +14479,12 @@ var traceFile = async (filePath, fs2, state) => {
   state.cache.set(filePath, promise);
   return promise;
 };
-var traceExports = async (entryPath, fs2) => {
+var traceExports = async (entryPath, fs2, resolver = { mappings: [] }) => {
   const state = {
     files: new Set,
     cache: new Map,
-    inFlight: new Set
+    inFlight: new Set,
+    resolver
   };
   const exportsList = await traceFile(entryPath, fs2, state);
   return {
@@ -14783,14 +14976,16 @@ var analyzeEnumDeclaration = (node2, name, symbolDoc, filePath, declarations) =>
     }
   });
 };
-var collectImportBindings2 = (root, relations) => {
+var collectImportBindings2 = async (root, filePath, fs2, resolver, relations) => {
   const bindings = new Map;
   for (const node2 of root.namedChildren.filter((child) => child.type === "import_statement")) {
     const specifierNode = node2.namedChildren.find((child) => child.type === "string");
     if (!specifierNode)
       continue;
     const specifier = specifierNode.text.replace(/^['"]/, "").replace(/['"]$/, "");
-    const isExternal = !specifier.startsWith(".");
+    const resolvedAlias = isRelativeModuleSpecifier(specifier) ? null : await resolveImportSourcePath(filePath, specifier, fs2, resolver);
+    const isExternal = !isRelativeModuleSpecifier(specifier) && resolvedAlias === null;
+    const relationTarget = resolvedAlias ?? specifier;
     const statementTypeOnly = node2.text.startsWith("import type ");
     let hasValueImport = !statementTypeOnly;
     let hasTypeImport = statementTypeOnly;
@@ -14821,15 +15016,15 @@ var collectImportBindings2 = (root, relations) => {
       }
     }
     if (hasValueImport) {
-      relations.push(createRelation("imports" /* Imports */, "", specifier, isExternal, getLine(node2)));
+      relations.push(createRelation("imports" /* Imports */, "", relationTarget, isExternal, getLine(node2)));
     }
     if (hasTypeImport) {
-      relations.push(createRelation("imports_type" /* ImportsType */, "", specifier, isExternal, getLine(node2)));
+      relations.push(createRelation("imports_type" /* ImportsType */, "", relationTarget, isExternal, getLine(node2)));
     }
   }
   return bindings;
 };
-var analyzeFile = async (filePath, fs2) => {
+var analyzeFile = async (filePath, fs2, resolver = { mappings: [] }) => {
   const source2 = await fs2.readFile(filePath);
   const tree = await parseFile(source2, filePath.endsWith(".tsx"));
   if (!tree) {
@@ -14842,7 +15037,7 @@ var analyzeFile = async (filePath, fs2) => {
   }
   const root = tree.rootNode;
   const relations = [];
-  const importBindings = collectImportBindings2(root, relations);
+  const importBindings = await collectImportBindings2(root, filePath, fs2, resolver, relations);
   const declarations = new Map;
   for (const relation of relations) {
     if (relation.from === "") {
@@ -14871,6 +15066,7 @@ var analyzeFile = async (filePath, fs2) => {
 
 // src/symbolExtractor.ts
 var extractSymbols = async (entries, fs2, options) => {
+  const resolver = await loadTsConfigPathResolver(fs2);
   const exportedSymbols = [];
   const internalSymbols = [];
   const relations = [];
@@ -14878,11 +15074,11 @@ var extractSymbols = async (entries, fs2, options) => {
   const exportedDeclarationKeys = new Set;
   const analyses = new Map;
   for (const entry of entries) {
-    const traced = await traceExports(entry.path, fs2);
+    const traced = await traceExports(entry.path, fs2, resolver);
     traced.files.forEach((filePath) => filePaths.add(filePath));
     for (const filePath of traced.files) {
       if (!analyses.has(filePath)) {
-        analyses.set(filePath, await analyzeFile(filePath, fs2));
+        analyses.set(filePath, await analyzeFile(filePath, fs2, resolver));
       }
     }
     for (const tracedExport of traced.exports) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/extract-ts",
-  "version": "0.6.0-beta.4",
+  "version": "0.6.0-beta.5",
   "type": "module",
   "dependencies": {
     "web-tree-sitter": "^0.20.8"