poe-code 3.0.392 → 3.0.393

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.392",
+  "version": "3.0.393",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/package-lint/dist/model.d.ts

@@ -34,6 +34,7 @@ export interface PackageInfo {
     bundledDependencies: string[];
     repositoryDirectory: string | undefined;
     ecosystem: Ecosystem;
+    main: string | undefined;
     exports: unknown;
     bin: Record<string, string>;
     files: string[];
@@ -49,6 +50,11 @@ export interface BinTarget {
     /** Owning package dir, e.g. "packages/superintendent". */
     dir: string;
 }
+export interface RootEntryPoint {
+    kind: "main" | "export" | "bin";
+    name: string;
+    target: string;
+}
 export interface ReleaseWorkflow {
     /** File name, e.g. "release-toolcraft.yml". */
     file: string;
@@ -75,6 +81,9 @@ export interface WorkspaceModel {
     binTargets: BinTarget[];
     /** Real import graph of each package's `src`, keyed by package dir. */
     sourceImports: SourceImportView;
+    /** Runtime imports of root package entrypoints that ship in the root tarball. */
+    shippedDistImports: SourceImportView;
+    rootEntryPoints: RootEntryPoint[];
     /** Runtime file assets discovered from package source, keyed by package dir. */
     runtimeFileAssets: RuntimeFileAssetView;
     /** Files included by each package artifact, keyed by package dir. */

package/packages/package-lint/dist/model.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { parse as parseYaml } from "yaml";
 import { createNpmPacklistProvider, loadPackageFileView } from "./packlist.js";
 import { scanRuntimeFileAssets } from "./runtime-files.js";
-import { scanSourceImports } from "./source-imports.js";
+import { scanImportFiles, scanSourceImports } from "./source-imports.js";
 function toPosix(p) {
     return p.replaceAll("\\", "/");
 }
@@ -100,6 +100,7 @@ async function loadPackage(fs, rootDir, relDir, isRoot) {
         bundledDependencies: toStringArray(pkg.bundledDependencies ?? pkg.bundleDependencies),
         repositoryDirectory: typeof repository?.directory === "string" ? repository.directory : undefined,
         ecosystem,
+        main: typeof pkg.main === "string" ? pkg.main : undefined,
         exports: pkg.exports,
         bin: toBinRecord(pkg.bin, typeof pkg.name === "string" ? pkg.name : relDir),
         files: Array.isArray(pkg.files)
@@ -133,6 +134,87 @@ function deriveShipped(root) {
     }
     return { shippedDirs, binTargets };
 }
+function normalizeRootTarget(target) {
+    const withoutDot = target.startsWith("./") ? target.slice(2) : target;
+    const normalized = toPosix(path.posix.normalize(toPosix(withoutDot)));
+    if (normalized.length === 0 ||
+        normalized === "." ||
+        normalized === ".." ||
+        normalized.startsWith("../") ||
+        path.posix.isAbsolute(normalized)) {
+        return undefined;
+    }
+    return normalized;
+}
+function exportImportTarget(value) {
+    if (typeof value === "string")
+        return normalizeRootTarget(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const target = exportImportTarget(item);
+            if (target)
+                return target;
+        }
+        return undefined;
+    }
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    for (const [key, raw] of Object.entries(record)) {
+        if (key === "types")
+            continue;
+        const target = exportImportTarget(raw);
+        if (target)
+            return target;
+    }
+    return undefined;
+}
+function isSubpathExportsMap(exportsField) {
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField)) {
+        return false;
+    }
+    return Object.keys(exportsField).some((key) => key.startsWith("."));
+}
+function deriveRootEntryPoints(root) {
+    const entryPoints = [];
+    const seen = new Set();
+    const add = (entry) => {
+        const key = `${entry.kind}:${entry.name}:${entry.target}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        entryPoints.push(entry);
+    };
+    if (root.main) {
+        const target = normalizeRootTarget(root.main);
+        if (target)
+            add({ kind: "main", name: ".", target });
+    }
+    if (isSubpathExportsMap(root.exports)) {
+        for (const [name, value] of Object.entries(root.exports)) {
+            const target = exportImportTarget(value);
+            if (target)
+                add({ kind: "export", name, target });
+        }
+    }
+    else {
+        const target = exportImportTarget(root.exports);
+        if (target)
+            add({ kind: "export", name: ".", target });
+    }
+    for (const [name, value] of Object.entries(root.bin)) {
+        const target = normalizeRootTarget(value);
+        if (target)
+            add({ kind: "bin", name, target });
+    }
+    return entryPoints.sort((a, b) => {
+        const byTarget = a.target.localeCompare(b.target);
+        if (byTarget !== 0)
+            return byTarget;
+        const byKind = a.kind.localeCompare(b.kind);
+        return byKind !== 0 ? byKind : a.name.localeCompare(b.name);
+    });
+}
 function dirFromArtifactPath(p) {
     const parts = toPosix(p).split("/").filter(Boolean);
     if (parts[parts.length - 1] === "dist")
@@ -274,6 +356,7 @@ export async function loadWorkspace(fs, rootDir, options = {}) {
     for (const p of packages)
         byDir.set(p.dir, p);
     const { shippedDirs, binTargets } = deriveShipped(root);
+    const rootEntryPoints = deriveRootEntryPoints(root);
     const workspaceNames = new Set(packages.map((p) => p.name));
     const sourceImportPackages = packages.map((pkg) => ({
         dir: pkg.dir,
@@ -284,8 +367,10 @@ export async function loadWorkspace(fs, rootDir, options = {}) {
         root,
         packages
     };
-    const [sourceImports, runtimeFileAssets, packageFiles] = await Promise.all([
+    const shippedDistEntryFiles = [...new Set(rootEntryPoints.map((entry) => entry.target))];
+    const [sourceImports, shippedDistImports, runtimeFileAssets, packageFiles] = await Promise.all([
         scanSourceImports(fs, rootDir, sourceImportPackages),
+        scanImportFiles(fs, rootDir, shippedDistEntryFiles),
         scanRuntimeFileAssets(fs, rootDir, runtimePackages),
         loadPackageFileView(options.packlistProvider ?? createNpmPacklistProvider(fs), {
             rootDir,
@@ -302,6 +387,8 @@ export async function loadWorkspace(fs, rootDir, options = {}) {
         shippedDirs,
         binTargets,
         sourceImports,
+        shippedDistImports,
+        rootEntryPoints,
         runtimeFileAssets,
         packageFiles
     };

package/packages/package-lint/dist/rules/shipped-dist-deps-unresolvable.js

@@ -9,6 +9,15 @@ function shippedPackageNames(model) {
     }
     return names;
 }
+function rootRuntimeDependencies(model) {
+    return new Set([
+        ...Object.keys(model.root.dependencies),
+        ...Object.keys(model.root.optionalDependencies)
+    ]);
+}
+function entryPointLabel(entry) {
+    return `${entry.kind}:${entry.name}`;
+}
 /**
  * Every runtime dependency of a shipped, tsc-emitted bin entry must resolve
  * from the published `poe-code` tarball: it is in root `dependencies`, a Node
@@ -20,7 +29,31 @@ export const shippedDistDepsUnresolvable = {
     run(model) {
         const violations = [];
         const shipped = shippedPackageNames(model);
-        const rootDeps = new Set(Object.keys(model.root.dependencies));
+        const rootDeps = rootRuntimeDependencies(model);
+        for (const entry of model.rootEntryPoints) {
+            const unresolved = new Set();
+            for (const ref of model.shippedDistImports.get(entry.target) ?? []) {
+                if (ref.kind !== "bare" || ref.typeOnly || !ref.packageName)
+                    continue;
+                if (ref.packageName === model.root.name)
+                    continue;
+                if (rootDeps.has(ref.packageName) || isBuiltin(ref.packageName))
+                    continue;
+                unresolved.add(ref.packageName);
+            }
+            if (unresolved.size === 0)
+                continue;
+            const names = [...unresolved].sort();
+            violations.push({
+                rule: id,
+                package: model.root.name,
+                severity: "error",
+                via: entryPointLabel(entry),
+                detail: { target: entry.target, unresolved: names },
+                message: "root package entrypoint imports bare names not in root dependencies (ERR_MODULE_NOT_FOUND on install)",
+                fix: `Bundle or rewrite ${entry.target}, or add each package to root "dependencies": ${names.join(", ")}.`
+            });
+        }
         for (const bin of model.binTargets) {
             const owner = model.byDir.get(bin.dir);
             if (!owner)

package/packages/package-lint/dist/source-imports.d.ts

@@ -17,7 +17,7 @@ export interface ImportRef {
 }
 /** Imports found in each workspace package, keyed by the package dir (posix). */
 export type SourceImportView = Map<string, ImportRef[]>;
-interface RawImport {
+export interface RawImport {
     specifier: string;
     typeOnly: boolean;
 }
@@ -33,4 +33,4 @@ export declare function scanSourceImports(fs: LintFs, rootDir: string, packages:
     dir: string;
     workspaceNames: ReadonlySet<string>;
 }>): Promise<SourceImportView>;
-export {};
+export declare function scanImportFiles(fs: LintFs, rootDir: string, files: string[]): Promise<SourceImportView>;

package/packages/package-lint/dist/source-imports.js

@@ -14,8 +14,18 @@ function isTestFile(relFile) {
     const segments = relFile.split("/");
     return segments.some((s) => s === "test" || s === "tests" || s === "__tests__");
 }
+function scriptKind(fileName) {
+    if (fileName.endsWith(".tsx"))
+        return ts.ScriptKind.TSX;
+    if (fileName.endsWith(".jsx"))
+        return ts.ScriptKind.JSX;
+    if (fileName.endsWith(".js") || fileName.endsWith(".mjs") || fileName.endsWith(".cjs")) {
+        return ts.ScriptKind.JS;
+    }
+    return ts.ScriptKind.TS;
+}
 function extractImportsFromAst(text, fileName) {
-    const sourceFile = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, false, fileName.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const sourceFile = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, false, scriptKind(fileName));
     const out = [];
     for (const statement of sourceFile.statements) {
         if (ts.isImportDeclaration(statement)) {
@@ -176,3 +186,20 @@ export async function scanSourceImports(fs, rootDir, packages) {
     }));
     return view;
 }
+export async function scanImportFiles(fs, rootDir, files) {
+    const view = new Map();
+    await Promise.all(files.map(async (relFile) => {
+        const normalized = path.posix.normalize(toPosix(relFile));
+        const absFile = path.join(rootDir, normalized);
+        let text;
+        try {
+            text = await fs.readFile(absFile);
+        }
+        catch {
+            return;
+        }
+        const refs = extractRelevantImports(text, absFile).map((raw) => classify(raw, rootDir, ".", absFile, normalized));
+        view.set(normalized, refs);
+    }));
+    return view;
+}