@archpilotlabs/archpilot 0.0.14 → 0.0.15

package/dist/archpilot-cli.js

@@ -211102,10 +211102,13 @@ var commonIgnoreDirectories = [
   "node_modules",
   ".git",
   ".archpilot",
+  ".next",
   "dist",
   "build",
   "out",
-  "coverage"
+  "coverage",
+  "fixtures",
+  "__fixtures__"
 ];
 var commonApiRoots = ["src/api", "api", "app/api"];
 var commonDatabaseRoots = ["db", "database", "prisma", "migrations"];
@@ -214843,9 +214846,13 @@ function hasDeclaredComponents(components) {
 }
 function getDeclaredComponentEntries(components) {
   const entries = Array.isArray(components) ? components.map((component, index) => [
-    component.id ?? `component-${index + 1}`,
+    component?.id ?? `component-${index + 1}`,
     component
-  ]) : Object.entries(components).sort(([left], [right]) => left.localeCompare(right));
+  ]).filter(
+    (entry) => Boolean(entry[1])
+  ) : Object.entries(components).filter(
+    (entry) => Boolean(entry[1])
+  ).sort(([left], [right]) => left.localeCompare(right));
   const seenPaths = /* @__PURE__ */ new Set();
   return entries.filter(([, component]) => {
     const normalizedPath = normalizeArchitectureWorkspacePath(component.path);
@@ -214882,9 +214889,13 @@ function normalizeResources(resources) {
     return void 0;
   }
   const entries = Array.isArray(resources) ? resources.map((resource, index) => [
-    resource.id ?? `resource-${index + 1}`,
+    resource?.id ?? `resource-${index + 1}`,
     resource
-  ]) : Object.entries(resources).sort(([left], [right]) => left.localeCompare(right));
+  ]).filter(
+    (entry) => Boolean(entry[1])
+  ) : Object.entries(resources).filter(
+    (entry) => Boolean(entry[1])
+  ).sort(([left], [right]) => left.localeCompare(right));
   return entries.map(([resourceId, resource]) => normalizeResource(resourceId, resource));
 }
 function normalizeArchitectureWorkspaceModel(contract) {
@@ -215256,6 +215267,31 @@ async function readPackageName(packageJsonPath) {
     return void 0;
   }
 }
+function collectPackageExportSubpaths(exportsValue) {
+  if (typeof exportsValue === "string") {
+    return ["."];
+  }
+  if (!exportsValue || typeof exportsValue !== "object" || Array.isArray(exportsValue)) {
+    return [];
+  }
+  return Object.keys(exportsValue).filter((key) => key === "." || key.startsWith("./")).sort((left, right) => left.localeCompare(right));
+}
+async function readPackagePublicExportSubpaths(moduleRoot) {
+  const contents = await readTextFileIfExists2(path7.join(moduleRoot, "package.json"));
+  if (!contents) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(contents);
+    const exportSubpaths = collectPackageExportSubpaths(parsed.exports);
+    if (exportSubpaths.length > 0) {
+      return exportSubpaths;
+    }
+    return typeof parsed.main === "string" && parsed.main.trim().length > 0 ? ["."] : [];
+  } catch {
+    return [];
+  }
+}
 async function buildWorkspacePackageAliasMap(workspaceRoot, moduleRoots) {
   const aliases = [];
   for (const [moduleId, moduleRoot] of [...moduleRoots.entries()].sort(
@@ -215269,7 +215305,8 @@ async function buildWorkspacePackageAliasMap(workspaceRoot, moduleRoots) {
       packageName,
       moduleId,
       moduleRoot,
-      targetRoot: await resolvePackageAliasSourceRoot(moduleRoot)
+      targetRoot: await resolvePackageAliasSourceRoot(moduleRoot),
+      publicExportSubpaths: await readPackagePublicExportSubpaths(moduleRoot)
     });
   }
   aliases.push(...await buildTsConfigPathAliasMap(workspaceRoot, moduleRoots));
@@ -215335,7 +215372,8 @@ async function buildTsConfigPathAliasMap(workspaceRoot, moduleRoots) {
           packageName: aliasPrefix,
           moduleId,
           moduleRoot,
-          targetRoot: absoluteTarget
+          targetRoot: absoluteTarget,
+          publicExportSubpaths: await readPackagePublicExportSubpaths(moduleRoot)
         });
         continue;
       }
@@ -215343,7 +215381,8 @@ async function buildTsConfigPathAliasMap(workspaceRoot, moduleRoots) {
         packageName: aliasPrefix,
         moduleId,
         moduleRoot,
-        targetFile: absoluteTarget
+        targetFile: absoluteTarget,
+        publicExportSubpaths: await readPackagePublicExportSubpaths(moduleRoot)
       });
     }
   }
@@ -215867,7 +215906,28 @@ function resolvePackageAliasRemainder(packageName, importSpecifier) {
   }
   return void 0;
 }
-async function resolveWorkspacePackageImportPath(importSpecifier, workspacePackageAliases, adapter) {
+function packageExportPatternMatches(pattern, subpath) {
+  if (!pattern.includes("*")) {
+    return pattern === subpath;
+  }
+  const [prefix, suffix = ""] = pattern.split("*", 2);
+  return subpath.startsWith(prefix) && subpath.endsWith(suffix);
+}
+function isImportSpecifierPackageExport(alias, importSpecifier) {
+  const remainder = resolvePackageAliasRemainder(alias.packageName, importSpecifier);
+  if (remainder === void 0) {
+    return false;
+  }
+  const exportSubpaths = alias.publicExportSubpaths ?? [];
+  if (exportSubpaths.length === 0) {
+    return false;
+  }
+  const importSubpath = remainder.length === 0 ? "." : `./${remainder}`;
+  return exportSubpaths.some(
+    (exportSubpath) => packageExportPatternMatches(exportSubpath, importSubpath)
+  );
+}
+async function resolveWorkspacePackageImportTarget(importSpecifier, workspacePackageAliases, adapter) {
   const packageAlias = workspacePackageAliases.map((alias2) => ({
     alias: alias2,
     remainder: resolvePackageAliasRemainder(alias2.packageName, importSpecifier)
@@ -215886,18 +215946,31 @@ async function resolveWorkspacePackageImportPath(importSpecifier, workspacePacka
   }
   const { alias, remainder } = packageAlias;
   if (remainder.length === 0) {
-    return resolveImportPath(alias.targetFile ?? alias.targetRoot ?? alias.moduleRoot, adapter);
+    const resolvedPath = await resolveImportPath(alias.targetFile ?? alias.moduleRoot, adapter) ?? (alias.targetRoot && alias.targetRoot !== alias.moduleRoot ? await resolveImportPath(alias.targetRoot, adapter) : void 0);
+    return resolvedPath ? {
+      alias,
+      resolvedPath,
+      isPublicPackageImport: isImportSpecifierPackageExport(alias, importSpecifier)
+    } : void 0;
   }
   if (alias.targetRoot) {
-    return resolveImportPath(
+    const resolvedPath = await resolveImportPath(
       path7.join(alias.targetRoot, ...remainder.split("/").filter((segment) => segment.length > 0)),
       adapter
     );
+    return resolvedPath ? {
+      alias,
+      resolvedPath,
+      isPublicPackageImport: isImportSpecifierPackageExport(alias, importSpecifier)
+    } : void 0;
   }
   return void 0;
 }
 async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, sourceFilePath, importSpecifier, adapter) {
   let basePath;
+  let packageAliasTargetModule;
+  let packageAliasTargetModuleRoot;
+  let isPublicPackageAliasImport = false;
   const normalizedModulesRoot = normalizePath3(modulesRootRelativePath).replace(/^\/+/, "");
   if (usesJavaImportParser(adapter) && !importSpecifier.startsWith(".")) {
     const resolvedJava = resolveJavaModuleImport(
@@ -215952,13 +216025,16 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   } else if (normalizedModulesRoot.startsWith("src/") && importSpecifier.startsWith(`${normalizedModulesRoot.slice("src/".length)}/`)) {
     basePath = path7.join(workspaceRoot, "src", importSpecifier);
   } else {
-    const workspacePackageImportPath = await resolveWorkspacePackageImportPath(
+    const workspacePackageImportTarget = await resolveWorkspacePackageImportTarget(
       importSpecifier,
       workspacePackageAliases,
       adapter
     );
-    if (workspacePackageImportPath) {
-      basePath = workspacePackageImportPath;
+    if (workspacePackageImportTarget) {
+      basePath = workspacePackageImportTarget.resolvedPath;
+      packageAliasTargetModule = workspacePackageImportTarget.alias.moduleId;
+      packageAliasTargetModuleRoot = workspacePackageImportTarget.alias.moduleRoot;
+      isPublicPackageAliasImport = workspacePackageImportTarget.isPublicPackageImport;
     } else {
       const moduleImportTarget = [...moduleRoots.entries()].filter(([moduleId]) => importSpecifier === moduleId || importSpecifier.startsWith(`${moduleId}/`)).sort((left, right) => right[0].length - left[0].length || left[0].localeCompare(right[0]))[0];
       if (moduleImportTarget) {
@@ -215975,7 +216051,7 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   if (!resolvedPath) {
     return void 0;
   }
-  const targetModuleEntry = [...moduleRoots.entries()].filter(([, moduleRoot]) => isPathInsideOrEqual2(resolvedPath, moduleRoot)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
+  const targetModuleEntry = packageAliasTargetModule && packageAliasTargetModuleRoot ? [packageAliasTargetModule, packageAliasTargetModuleRoot] : [...moduleRoots.entries()].filter(([, moduleRoot]) => isPathInsideOrEqual2(resolvedPath, moduleRoot)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
   if (!targetModuleEntry) {
     const standaloneTargetModule = explicitStandaloneModuleByPath.get(
       normalizePath3(path7.relative(workspaceRoot, resolvedPath))
@@ -216000,13 +216076,14 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   const nestedIndexEntrypointCandidates = adapter.dependencyParsingFileExtensions.flatMap(
     (extension) => [`src/index${extension}`, `public/index${extension}`]
   );
-  const isPublicImport = indexEntrypointCandidates.includes(targetSubPath) || nestedIndexEntrypointCandidates.includes(targetSubPath) || adapter.publicEntrypointDirectoryNames.some(
+  const isPublicImport = isPublicPackageAliasImport || indexEntrypointCandidates.includes(targetSubPath) || nestedIndexEntrypointCandidates.includes(targetSubPath) || adapter.publicEntrypointDirectoryNames.some(
     (dirName) => targetSubPath.startsWith(`${dirName}/`)
   );
   return {
     targetModule,
     resolvedRelativePath: normalizePath3(path7.relative(workspaceRoot, resolvedPath)),
-    isPublicImport
+    isPublicImport,
+    ...isPublicPackageAliasImport ? { isPackagePublicImport: true } : {}
   };
 }
 async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, adapter, options) {
@@ -216059,6 +216136,7 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
           line: importReference.line,
           targetModule: resolved.targetModule,
           isPublicImport: resolved.isPublicImport,
+          ...resolved.isPackagePublicImport ? { isPackagePublicImport: true } : {},
           resolvedTargetRelativePath: resolved.resolvedRelativePath
         });
       }
@@ -216814,6 +216892,9 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
       if (options.suppressPublicSurfaceFailuresForNonPublicImports === true && !dependencyImport.isPublicImport) {
         continue;
       }
+      if (dependencyImport.isPackagePublicImport === true) {
+        continue;
+      }
       if (!isImportWithinPublicEntrypoints(
         dependencyImport.resolvedTargetRelativePath,
         publicEntrypoints
@@ -218687,6 +218768,9 @@ var archpilotIgnoreFileName = ".archpilotignore";
 var defaultArchpilotIgnoreContent = [
   "node_modules/",
   ".git/",
+  ".archpilot/reports/",
+  ".archpilot/history/",
+  ".archpilot/badges/",
   ".next/",
   "dist/",
   "build/",
@@ -218751,7 +218835,9 @@ function loadArchpilotIgnoreMatcher(workspaceRoot) {
   } catch {
     contents = void 0;
   }
-  return createArchpilotIgnoreMatcher(contents ? parseArchpilotIgnore(contents) : []);
+  const defaultPatterns = parseArchpilotIgnore(defaultArchpilotIgnoreContent);
+  const customPatterns = contents ? parseArchpilotIgnore(contents) : [];
+  return createArchpilotIgnoreMatcher([...defaultPatterns, ...customPatterns]);
 }
 function ensureArchpilotIgnoreFileSync(workspaceRoot) {
   const ignorePath = path13.join(workspaceRoot, archpilotIgnoreFileName);
@@ -224434,7 +224520,18 @@ async function validateDependencyGraphIsolation(workspaceRoot, contract, depende
     for (const entry of entries) {
       const fullPath = path27.join(directoryPath, entry.name);
       if (entry.isDirectory()) {
-        if (["node_modules", "dist", "out", "build", "coverage", ".git"].includes(entry.name)) {
+        if ([
+          "node_modules",
+          ".git",
+          ".archpilot",
+          ".next",
+          "dist",
+          "out",
+          "build",
+          "coverage",
+          "fixtures",
+          "__fixtures__"
+        ].includes(entry.name)) {
           continue;
         }
         const nested = await collectModuleSourceEvidence2(fullPath);
@@ -225148,6 +225245,7 @@ async function writeValidationReport(workspaceRoot, config, results, validationC
     policyStatus,
     adrSummary
   );
+  statusExport.xArchPilot = await buildManagedMetadata("validation-status", timestampIso);
   let healthTrend = {
     currentScore: statusExport.summary.healthScore,
     trendDirection: "no-history"
@@ -225463,6 +225561,14 @@ async function runArchitectureValidationForWorkspace(workspaceRoot, options) {
       modulesRootRelativePath: configuredModulesRoot
     })
   );
+  emitOperationalMessage(
+    options?.onOperationalMessage,
+    "info",
+    `Dependency scan summary: modules=${dependencyGraphSummary.modules.length}, importEdges=${dependencyGraphSummary.modules.reduce(
+      (total, moduleEntry) => total + moduleEntry.actualDependencies.length,
+      0
+    )}, ignoredDefaults=node_modules,.git,.archpilot,dist,build,out,coverage,fixtures.`
+  );
   results.push(
     ...await phase(
       "Analyzing dependency graph rules",
@@ -226813,6 +226919,7 @@ function renderArchitectureReviewJson(summary, options) {
   );
   return `${JSON.stringify(
     {
+      ...options?.metadata ? { xArchPilot: options.metadata } : {},
       reportVersion: summary.reportVersion,
       projectName: summary.projectName,
       generatedAtUtc: summary.generatedAtUtc,
@@ -231674,6 +231781,10 @@ async function writeArchitectureReportArtifacts(input2) {
   let reportWriteError;
   try {
     const modulePaths = await readModulePaths(input2.workspaceRoot);
+    const summaryMetadata = await buildManagedMetadata(
+      "validation-summary",
+      input2.reviewSummary.generatedAtUtc
+    );
     await import_node_fs34.promises.mkdir(reportsDir, { recursive: true });
     await Promise.all([
       import_node_fs34.promises.writeFile(
@@ -231695,6 +231806,7 @@ async function writeArchitectureReportArtifacts(input2) {
       import_node_fs34.promises.writeFile(
         reviewJsonPath,
         renderArchitectureReviewJson(input2.reviewSummary, {
+          metadata: summaryMetadata,
           remediation: input2.remediation,
           suppressionSummary: input2.suppressionSummary,
           dependencyGraphSummary: input2.dependencyGraphSummary,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archpilotlabs/archpilot",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "Executable architecture governance CLI",
   "homepage": "https://archpilot.org",
   "bugs": {