ts-axi 0.1.2 → 0.1.3

package/dist/src/workspace.js

@@ -0,0 +1,297 @@
+// Workspace detection (no configuration): which kind of repo this is, its projects,
+// path aliases and workspace packages. Reads files only; never writes, never caches.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { matchesGlob } from "./glob.js";
+import { listFiles, toRel } from "./walk.js";
+/** Most specific first. */
+const KIND_ORDER = ["nx", "pnpm-workspaces", "npm-workspaces", "tsconfig-references", "single", "implicit"];
+const MULTI = new Set(["nx", "pnpm-workspaces", "npm-workspaces", "tsconfig-references"]);
+export const WORKSPACE_SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+const LIST_CAP = 200_000;
+export function isMultiProject(kind) {
+    return MULTI.has(kind);
+}
+const KIND_LABELS = {
+    nx: "nx workspace",
+    "pnpm-workspaces": "pnpm workspace",
+    "npm-workspaces": "npm workspace",
+    "tsconfig-references": "tsconfig references",
+    single: "single project",
+    implicit: "implicit project",
+};
+export function kindLabel(kind) {
+    return KIND_LABELS[kind];
+}
+/** JSON with comments and trailing commas (tsconfig style); undefined when unreadable. */
+export function readJsonc(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    let outText = "";
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"') {
+            const start = i;
+            for (i++; i < text.length && text[i] !== '"'; i++)
+                if (text[i] === "\\")
+                    i++;
+            outText += text.slice(start, i + 1);
+        }
+        else if (ch === "/" && text[i + 1] === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            outText += "\n";
+        }
+        else if (ch === "/" && text[i + 1] === "*") {
+            const end = text.indexOf("*/", i + 2);
+            i = end < 0 ? text.length : end + 1;
+        }
+        else
+            outText += ch;
+    }
+    try {
+        const value = JSON.parse(outText.replace(/,(\s*[}\]])/g, "$1"));
+        return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSourceName(name) {
+    return WORKSPACE_SOURCE_EXTENSIONS.some((ext) => name.endsWith(ext)) && !/\.d\.[mc]?ts$/.test(name);
+}
+/** Repo-root-relative files of the workspace (shared listing, `src/walk.ts`). */
+export function listWorkspaceFiles(root) {
+    const listing = listFiles(root, () => true, { maxFiles: LIST_CAP });
+    return { files: listing.files.map((f) => toRel(root, f)), listedBy: listing.listedBy };
+}
+/** Role of a tsconfig by its name, then by its `include` patterns. */
+export function classifyTsconfig(path) {
+    const name = basename(path);
+    if (name === "tsconfig.json")
+        return "root";
+    if (/^tsconfig\.base\./.test(name))
+        return "base";
+    if (/(?:^|\.)lib(?:\.|$)/.test(name.replace(/^tsconfig\./, "").replace(/\.json$/, "")))
+        return "lib";
+    if (/\.app\.json$/.test(name))
+        return "app";
+    if (/\.(?:spec|test|tests|vitest|jest)\.json$/.test(name))
+        return "spec";
+    if (/\.(?:e2e|cy|cypress|playwright)\.json$/.test(name))
+        return "e2e";
+    const include = readJsonc(path)?.["include"];
+    const patterns = Array.isArray(include) ? include.filter((p) => typeof p === "string") : [];
+    if (patterns.some((p) => /e2e|\.cy\./.test(p)))
+        return "e2e";
+    if (patterns.some((p) => /\.(?:spec|test)\.|__tests__/.test(p)))
+        return "spec";
+    return "other";
+}
+function tsconfigsIn(dir) {
+    try {
+        return readdirSync(dir)
+            .filter((n) => /^tsconfig.*\.json$/.test(n))
+            .map((n) => join(dir, n))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+/** `packages:` list of a pnpm-workspace.yaml (block or flow style). */
+export function pnpmPackageGlobs(text) {
+    const globs = [];
+    const lines = text.split(/\r?\n/);
+    const unquote = (s) => s.trim().replace(/^['"]|['"]$/g, "");
+    for (let i = 0; i < lines.length; i++) {
+        const m = /^packages\s*:\s*(.*)$/.exec(lines[i]);
+        if (!m)
+            continue;
+        const inline = m[1].replace(/#.*$/, "").trim();
+        if (inline.startsWith("["))
+            return inline.replace(/^\[|\]$/g, "").split(",").map(unquote).filter((g) => g !== "");
+        for (let j = i + 1; j < lines.length; j++) {
+            const line = lines[j].replace(/#.*$/, "");
+            if (line.trim() === "")
+                continue;
+            const item = /^\s+-\s*(.+)$/.exec(line);
+            if (!item)
+                break;
+            globs.push(unquote(item[1]));
+        }
+    }
+    return globs;
+}
+/** Directories (repo-relative) holding a `package.json` that match workspace globs (`!` negates). */
+function matchPackageDirs(globs, packageDirs) {
+    const positive = globs.filter((g) => !g.startsWith("!")).map((g) => g.replace(/^\.\//, "").replace(/\/$/, ""));
+    const negative = globs.filter((g) => g.startsWith("!")).map((g) => g.slice(1).replace(/^\.\//, "").replace(/\/$/, ""));
+    return packageDirs.filter((d) => d !== "" && positive.some((g) => matchesGlob(d, g)) && !negative.some((g) => matchesGlob(d, g)));
+}
+/** The first string target of an `exports` condition object, preferring source-ish conditions. */
+function exportTargets(value) {
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(exportTargets);
+    if (value && typeof value === "object") {
+        const record = value;
+        const order = ["source", "development", "types", "import", "module", "default", "require", "node"];
+        const keys = [...order.filter((k) => k in record), ...Object.keys(record).filter((k) => !order.includes(k))];
+        return keys.flatMap((k) => exportTargets(record[k]));
+    }
+    return [];
+}
+function readPackage(dir) {
+    const pkg = readJsonc(join(dir, "package.json"));
+    const name = pkg?.["name"];
+    if (!pkg || typeof name !== "string" || name === "")
+        return undefined;
+    const exportsMap = {};
+    const add = (sub, targets) => {
+        exportsMap[sub] = [...(exportsMap[sub] ?? []), ...targets.map((t) => resolve(dir, t))];
+    };
+    const raw = pkg["exports"];
+    if (typeof raw === "string" || Array.isArray(raw))
+        add(".", exportTargets(raw));
+    else if (raw && typeof raw === "object") {
+        const record = raw;
+        if (Object.keys(record).some((k) => k.startsWith("."))) {
+            for (const [sub, target] of Object.entries(record))
+                if (sub.startsWith("."))
+                    add(sub, exportTargets(target));
+        }
+        else
+            add(".", exportTargets(record));
+    }
+    const fields = ["source", "types", "typings", "module", "main"].map((k) => pkg[k]).filter((v) => typeof v === "string");
+    add(".", [...fields, "src/index", "index"]);
+    return { name, dir, exports: exportsMap };
+}
+/** `compilerOptions.paths` of tsconfig.base.json (else tsconfig.json), following relative `extends`. */
+export function readPathAliases(root) {
+    const start = [join(root, "tsconfig.base.json"), join(root, "tsconfig.json")].find((f) => existsSync(f));
+    let file = start;
+    for (let hops = 0; file && hops < 5; hops++) {
+        const config = readJsonc(file);
+        if (!config)
+            return undefined;
+        const options = (config["compilerOptions"] ?? {});
+        const paths = options["paths"];
+        if (paths && typeof paths === "object" && !Array.isArray(paths)) {
+            const clean = {};
+            for (const [k, v] of Object.entries(paths))
+                clean[k] = stringArray(v);
+            const baseUrl = typeof options["baseUrl"] === "string" ? options["baseUrl"] : undefined;
+            return { file, base: resolve(dirname(file), baseUrl ?? "."), paths: clean };
+        }
+        const ext = config["extends"];
+        const next = typeof ext === "string" && ext.startsWith(".") ? resolve(dirname(file), ext) : undefined;
+        file = next && !next.endsWith(".json") && !existsSync(next) ? `${next}.json` : next;
+    }
+    return undefined;
+}
+/** Root tsconfig with `references` and no files/include of its own. */
+function referencesOnly(config) {
+    if (!config)
+        return false;
+    const refs = config["references"];
+    const own = (key) => Array.isArray(config[key]) && config[key].length > 0;
+    return Array.isArray(refs) && refs.length > 0 && !own("files") && !own("include");
+}
+function project(root, relDir, name) {
+    const dir = relDir === "" ? root : join(root, relDir);
+    return { name: name ?? (relDir || basename(root)), dir, tsconfigs: tsconfigsIn(dir) };
+}
+/** Cheap pre-check (no file listing): could `root` be a multi-project workspace? */
+export function hasMultiProjectSignal(root) {
+    if (existsSync(join(root, "nx.json")) || existsSync(join(root, "pnpm-workspace.yaml")))
+        return true;
+    if (readJsonc(join(root, "package.json"))?.["workspaces"] !== undefined)
+        return true;
+    return referencesOnly(readJsonc(join(root, "tsconfig.json")));
+}
+export function detectWorkspace(root) {
+    const { files, listedBy } = listWorkspaceFiles(root);
+    const dirsWith = (fileName) => files.filter((f) => f === fileName || f.endsWith(`/${fileName}`)).map((f) => (f === fileName ? "" : f.slice(0, -fileName.length - 1)));
+    const packageDirs = dirsWith("package.json");
+    const signals = [];
+    const byKind = new Map();
+    if (existsSync(join(root, "nx.json"))) {
+        signals.push("nx");
+        const projects = dirsWith("project.json").map((d) => {
+            const name = readJsonc(join(root, d, "project.json"))?.["name"];
+            return project(root, d, typeof name === "string" ? name : undefined);
+        });
+        const legacy = readJsonc(join(root, "workspace.json"))?.["projects"];
+        if (legacy && typeof legacy === "object") {
+            for (const [name, value] of Object.entries(legacy)) {
+                const dir = typeof value === "string" ? value : value?.root;
+                if (typeof dir === "string" && !projects.some((p) => p.dir === join(root, dir)))
+                    projects.push(project(root, dir.replace(/\/$/, ""), name));
+            }
+        }
+        byKind.set("nx", projects);
+    }
+    const pnpmFile = join(root, "pnpm-workspace.yaml");
+    if (existsSync(pnpmFile)) {
+        const globs = pnpmPackageGlobs(readFileSync(pnpmFile, "utf8"));
+        if (globs.length > 0) {
+            signals.push("pnpm-workspaces");
+            byKind.set("pnpm-workspaces", matchPackageDirs(globs, packageDirs).map((d) => project(root, d, readPackage(join(root, d))?.name)));
+        }
+    }
+    const rootPkg = readJsonc(join(root, "package.json"));
+    const ws = rootPkg?.["workspaces"];
+    const npmGlobs = Array.isArray(ws) ? stringArray(ws) : stringArray(ws?.packages);
+    if (npmGlobs.length > 0) {
+        signals.push("npm-workspaces");
+        byKind.set("npm-workspaces", matchPackageDirs(npmGlobs, packageDirs).map((d) => project(root, d, readPackage(join(root, d))?.name)));
+    }
+    const rootTsconfig = join(root, "tsconfig.json");
+    const rootConfig = existsSync(rootTsconfig) ? readJsonc(rootTsconfig) : undefined;
+    if (referencesOnly(rootConfig)) {
+        signals.push("tsconfig-references");
+        const refs = rootConfig["references"].map((r) => r.path).filter((p) => typeof p === "string");
+        const dirs = refs.map((p) => {
+            const abs = resolve(root, p);
+            return existsSync(abs) && statSync(abs).isFile() ? dirname(abs) : abs;
+        });
+        byKind.set("tsconfig-references", [...new Set(dirs)].map((d) => project(root, relative(root, d).split(sep).join("/"))));
+    }
+    else if (existsSync(rootTsconfig)) {
+        signals.push("single");
+        byKind.set("single", [project(root, "")]);
+    }
+    if (signals.length === 0)
+        signals.push("implicit");
+    signals.sort((a, b) => KIND_ORDER.indexOf(a) - KIND_ORDER.indexOf(b));
+    const kind = signals[0];
+    // Workspace packages: package.json with a name in any project dir or matched workspace dir.
+    const pkgDirs = new Set();
+    for (const list of byKind.values())
+        for (const p of list)
+            if (p.dir !== root && existsSync(join(p.dir, "package.json")))
+                pkgDirs.add(p.dir);
+    const packages = [...pkgDirs].map(readPackage).filter((p) => p !== undefined);
+    const paths = readPathAliases(root);
+    return {
+        root,
+        kind,
+        signals,
+        projects: (byKind.get(kind) ?? []).sort((a, b) => a.dir.localeCompare(b.dir)),
+        ...(paths ? { paths } : {}),
+        packages,
+        sourceFiles: files.filter((f) => isSourceName(f)).map((f) => join(root, f)),
+        listedBy,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-axi",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "AXI-compliant TypeScript symbol CLI for agents - definitions, references, callers, file outlines and change impact (blast radius) with token-efficient TOON output",
   "type": "module",
   "keywords": [