@doccov/sdk 0.24.0 → 0.24.2

package/dist/index.js

@@ -51,7 +51,7 @@ import {
   saveSnapshot,
   serializeJSDoc,
   ts
-} from "./shared/chunk-c1f9mytc.js";
+} from "./shared/chunk-p1stkhse.js";
 import {
   mergeFilters,
   parseListFlag
@@ -67,6 +67,140 @@ import {
   getReportPath
 } from "./shared/chunk-esptwrfq.js";
 
+// src/analysis/doccov-builder.ts
+import { DRIFT_CATEGORIES as DRIFT_CATEGORIES2 } from "@doccov/spec";
+function buildDocCovSpec(options) {
+  const { openpkg, openpkgPath } = options;
+  const registry = buildExportRegistry(openpkg);
+  const exports = {};
+  let totalScore = 0;
+  let documentedCount = 0;
+  const missingByRule = {
+    description: 0,
+    params: 0,
+    returns: 0,
+    examples: 0,
+    throws: 0
+  };
+  const driftByCategory = {
+    structural: 0,
+    semantic: 0,
+    example: 0
+  };
+  let totalDrift = 0;
+  let fixableDrift = 0;
+  for (const exp of openpkg.exports ?? []) {
+    const coverage = computeExportCoverage(exp);
+    const rawDrifts = computeExportDrift(exp, registry);
+    const categorizedDrifts = rawDrifts.map((d) => toCategorizedDrift(d));
+    const exportId = exp.id ?? exp.name;
+    exports[exportId] = {
+      coverageScore: coverage.score,
+      missing: coverage.missing.length > 0 ? coverage.missing : undefined,
+      drift: categorizedDrifts.length > 0 ? categorizedDrifts : undefined
+    };
+    totalScore += coverage.score;
+    if (coverage.score === 100)
+      documentedCount++;
+    for (const rule of coverage.missing) {
+      missingByRule[rule]++;
+    }
+    for (const d of categorizedDrifts) {
+      driftByCategory[d.category]++;
+      totalDrift++;
+      if (d.fixable)
+        fixableDrift++;
+    }
+  }
+  const exportCount = openpkg.exports?.length ?? 0;
+  const summary = {
+    score: exportCount > 0 ? Math.round(totalScore / exportCount) : 100,
+    totalExports: exportCount,
+    documentedExports: documentedCount,
+    missingByRule,
+    drift: {
+      total: totalDrift,
+      fixable: fixableDrift,
+      byCategory: driftByCategory
+    }
+  };
+  return {
+    doccov: "1.0.0",
+    source: {
+      file: openpkgPath,
+      specVersion: openpkg.openpkg,
+      packageName: openpkg.meta.name,
+      packageVersion: openpkg.meta.version
+    },
+    generatedAt: new Date().toISOString(),
+    summary,
+    exports
+  };
+}
+function computeExportCoverage(exp) {
+  const missing = [];
+  let points = 0;
+  let maxPoints = 0;
+  maxPoints += 30;
+  if (exp.description && exp.description.trim().length > 0) {
+    points += 30;
+  } else {
+    missing.push("description");
+  }
+  const isCallable = exp.kind === "function" || exp.kind === "class";
+  if (isCallable && exp.signatures?.length) {
+    const sig = exp.signatures[0];
+    const params = sig.parameters ?? [];
+    if (params.length > 0) {
+      maxPoints += 25;
+      const documentedParams = params.filter((p) => p.description && p.description.trim().length > 0);
+      if (documentedParams.length === params.length) {
+        points += 25;
+      } else if (documentedParams.length > 0) {
+        points += Math.round(documentedParams.length / params.length * 25);
+        missing.push("params");
+      } else {
+        missing.push("params");
+      }
+    }
+    if (exp.kind === "function" && sig.returns) {
+      maxPoints += 20;
+      if (sig.returns.description && sig.returns.description.trim().length > 0) {
+        points += 20;
+      } else {
+        missing.push("returns");
+      }
+    }
+    if (sig.throws && sig.throws.length > 0) {
+      maxPoints += 10;
+      const documentedThrows = sig.throws.filter((t) => t.description);
+      if (documentedThrows.length === sig.throws.length) {
+        points += 10;
+      } else {
+        missing.push("throws");
+      }
+    }
+  }
+  maxPoints += 15;
+  if (exp.examples && exp.examples.length > 0) {
+    points += 15;
+  } else {
+    missing.push("examples");
+  }
+  const score = maxPoints > 0 ? Math.round(points / maxPoints * 100) : 100;
+  return { score, missing };
+}
+function toCategorizedDrift(drift) {
+  const driftType = drift.type;
+  return {
+    type: driftType,
+    target: drift.target,
+    issue: drift.issue,
+    suggestion: drift.suggestion,
+    category: DRIFT_CATEGORIES2[driftType],
+    fixable: isFixableDrift(drift)
+  };
+}
 // src/openpkg.ts
 import * as fsSync from "node:fs";
 import * as fs5 from "node:fs/promises";
@@ -4191,163 +4325,130 @@ function resolvePackageDir(entryFile) {
     currentDir = parentDir;
   }
 }
-// src/analysis/doccov-builder.ts
-import { DRIFT_CATEGORIES as DRIFT_CATEGORIES2 } from "@doccov/spec";
-function buildDocCovSpec(options) {
-  const { openpkg, openpkgPath } = options;
-  const registry = buildExportRegistry(openpkg);
-  const exports = {};
-  let totalScore = 0;
-  let documentedCount = 0;
-  const missingByRule = {
-    description: 0,
-    params: 0,
-    returns: 0,
-    examples: 0,
-    throws: 0
-  };
-  const driftByCategory = {
-    structural: 0,
-    semantic: 0,
-    example: 0
-  };
-  let totalDrift = 0;
-  let fixableDrift = 0;
-  for (const exp of openpkg.exports ?? []) {
-    const coverage = computeExportCoverage(exp);
-    const rawDrifts = computeExportDrift(exp, registry);
-    const categorizedDrifts = rawDrifts.map((d) => toCategorizedDrift(d));
-    const exportId = exp.id ?? exp.name;
-    exports[exportId] = {
-      coverageScore: coverage.score,
-      missing: coverage.missing.length > 0 ? coverage.missing : undefined,
-      drift: categorizedDrifts.length > 0 ? categorizedDrifts : undefined
-    };
-    totalScore += coverage.score;
-    if (coverage.score === 100)
-      documentedCount++;
-    for (const rule of coverage.missing) {
-      missingByRule[rule]++;
-    }
-    for (const d of categorizedDrifts) {
-      driftByCategory[d.category]++;
-      totalDrift++;
-      if (d.fixable)
-        fixableDrift++;
-    }
-  }
-  const exportCount = openpkg.exports?.length ?? 0;
-  const summary = {
-    score: exportCount > 0 ? Math.round(totalScore / exportCount) : 100,
-    totalExports: exportCount,
-    documentedExports: documentedCount,
-    missingByRule,
-    drift: {
-      total: totalDrift,
-      fixable: fixableDrift,
-      byCategory: driftByCategory
-    }
-  };
-  return {
-    doccov: "1.0.0",
-    source: {
-      file: openpkgPath,
-      specVersion: openpkg.openpkg,
-      packageName: openpkg.meta.name,
-      packageVersion: openpkg.meta.version
-    },
-    generatedAt: new Date().toISOString(),
-    summary,
-    exports
-  };
+// src/config/types.ts
+function defineConfig(config) {
+  return config;
 }
-function computeExportCoverage(exp) {
-  const missing = [];
-  let points = 0;
-  let maxPoints = 0;
-  maxPoints += 30;
-  if (exp.description && exp.description.trim().length > 0) {
-    points += 30;
-  } else {
-    missing.push("description");
+// src/detect/utils.ts
+async function safeParseJson(fs6, path9) {
+  try {
+    if (!await fs6.exists(path9))
+      return null;
+    const content = await fs6.readFile(path9);
+    return JSON.parse(content);
+  } catch {
+    return null;
   }
-  const isCallable = exp.kind === "function" || exp.kind === "class";
-  if (isCallable && exp.signatures?.length) {
-    const sig = exp.signatures[0];
-    const params = sig.parameters ?? [];
-    if (params.length > 0) {
-      maxPoints += 25;
-      const documentedParams = params.filter((p) => p.description && p.description.trim().length > 0);
-      if (documentedParams.length === params.length) {
-        points += 25;
-      } else if (documentedParams.length > 0) {
-        points += Math.round(documentedParams.length / params.length * 25);
-        missing.push("params");
-      } else {
-        missing.push("params");
-      }
-    }
-    if (exp.kind === "function" && sig.returns) {
-      maxPoints += 20;
-      if (sig.returns.description && sig.returns.description.trim().length > 0) {
-        points += 20;
-      } else {
-        missing.push("returns");
-      }
-    }
-    if (sig.throws && sig.throws.length > 0) {
-      maxPoints += 10;
-      const documentedThrows = sig.throws.filter((t) => t.description);
-      if (documentedThrows.length === sig.throws.length) {
-        points += 10;
-      } else {
-        missing.push("throws");
-      }
-    }
-  }
-  maxPoints += 15;
-  if (exp.examples && exp.examples.length > 0) {
-    points += 15;
-  } else {
-    missing.push("examples");
-  }
-  const score = maxPoints > 0 ? Math.round(points / maxPoints * 100) : 100;
-  return { score, missing };
 }
-function toCategorizedDrift(drift) {
-  const driftType = drift.type;
+async function readPackageJson(fs6, dir) {
+  const path9 = dir === "." ? "package.json" : `${dir}/package.json`;
+  return safeParseJson(fs6, path9);
+}
+
+// src/detect/build.ts
+var BUILD_SCRIPT_NAMES = new Set([
+  "build",
+  "compile",
+  "tsc",
+  "bundle",
+  "prepare",
+  "prepublish",
+  "prepublishOnly"
+]);
+var BUILD_SCRIPT_PREFIXES = ["build:", "compile:", "bundle:"];
+var BUILD_TOOL_PATTERNS = [
+  "tsc",
+  "esbuild",
+  "rollup",
+  "webpack",
+  "vite build",
+  "parcel build",
+  "swc",
+  "tsup",
+  "unbuild",
+  "bunup",
+  "pkgroll",
+  "microbundle",
+  "babel",
+  "ncc build"
+];
+async function detectBuildInfo(fs6, packagePath = ".") {
+  const pkgJson = await readPackageJson(fs6, packagePath);
+  const scripts = pkgJson?.scripts ?? {};
+  const scriptNames = Object.keys(scripts);
+  const buildScriptsByName = scriptNames.filter((name) => BUILD_SCRIPT_NAMES.has(name) || BUILD_SCRIPT_PREFIXES.some((prefix) => name.startsWith(prefix)));
+  const buildScriptsByContent = scriptNames.filter((name) => {
+    if (buildScriptsByName.includes(name))
+      return false;
+    const content = scripts[name] ?? "";
+    return BUILD_TOOL_PATTERNS.some((tool) => content.includes(tool) && !content.includes(`${tool}-`));
+  });
+  const buildScripts = [...new Set([...buildScriptsByName, ...buildScriptsByContent])];
+  const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
+  const hasTsConfig = await fs6.exists(tsconfigPath);
+  const hasTsDep = pkgJson?.devDependencies?.typescript !== undefined || pkgJson?.dependencies?.typescript !== undefined;
+  const hasTypeScript = hasTsConfig || hasTsDep;
+  const wasm = await detectWasmProject(fs6, packagePath, pkgJson);
+  const napi = detectNapiProject(pkgJson);
   return {
-    type: driftType,
-    target: drift.target,
-    issue: drift.issue,
-    suggestion: drift.suggestion,
-    category: DRIFT_CATEGORIES2[driftType],
-    fixable: isFixableDrift(drift)
+    scripts: buildScripts,
+    hasBuildScript: buildScripts.length > 0,
+    hasTypeScript,
+    exoticIndicators: { wasm, napi }
   };
 }
-// src/config/types.ts
-function defineConfig(config) {
-  return config;
-}
-// src/resolve/index.ts
-import * as path9 from "node:path";
-
-// src/detect/utils.ts
-async function safeParseJson(fs6, path9) {
-  try {
-    if (!await fs6.exists(path9))
-      return null;
-    const content = await fs6.readFile(path9);
-    return JSON.parse(content);
-  } catch {
-    return null;
+var WASM_PACKAGES = new Set([
+  "wasm-pack",
+  "@aspect/wasm-pack",
+  "@aspect-build/wasm-pack",
+  "@aspect/rules_js",
+  "wasm-bindgen",
+  "@aspect/aspect-cli"
+]);
+async function detectWasmProject(fs6, packagePath, pkgJson) {
+  const pkgCargoPath = packagePath === "." ? "Cargo.toml" : `${packagePath}/Cargo.toml`;
+  if (await fs6.exists(pkgCargoPath))
+    return true;
+  if (packagePath !== "." && await fs6.exists("Cargo.toml"))
+    return true;
+  if (pkgJson) {
+    const deps = Object.keys({
+      ...pkgJson.dependencies ?? {},
+      ...pkgJson.devDependencies ?? {}
+    });
+    if (deps.some((dep) => WASM_PACKAGES.has(dep))) {
+      return true;
+    }
   }
+  return false;
 }
-async function readPackageJson(fs6, dir) {
-  const path9 = dir === "." ? "package.json" : `${dir}/package.json`;
-  return safeParseJson(fs6, path9);
+var NAPI_PACKAGES = new Set([
+  "@napi-rs/cli",
+  "@aspect/napi-cli",
+  "napi",
+  "napi-build",
+  "napi-rs",
+  "neon",
+  "@aspect/neon-cli"
+]);
+function detectNapiProject(pkgJson) {
+  if (!pkgJson)
+    return false;
+  const deps = Object.keys({
+    ...pkgJson.dependencies ?? {},
+    ...pkgJson.devDependencies ?? {}
+  });
+  return deps.some((dep) => NAPI_PACKAGES.has(dep) || dep.includes("@aspect/napi"));
+}
+function getPrimaryBuildScript(buildInfo) {
+  if (buildInfo.scripts.includes("build"))
+    return "build";
+  if (buildInfo.scripts.includes("compile"))
+    return "compile";
+  if (buildInfo.scripts.includes("tsc"))
+    return "tsc";
+  return buildInfo.scripts[0] ?? null;
 }
-
 // src/detect/entry-point.ts
 async function detectEntryPoint(fs6, packagePath = ".") {
   const pkgJson = await readPackageJson(fs6, packagePath);
@@ -4472,13 +4573,110 @@ async function resolveToSource(fs6, basePath, filePath, tsConfig) {
   }
   return null;
 }
+// src/detect/filesystem.ts
+import * as fs6 from "node:fs";
+import * as nodePath from "node:path";
+import { Writable } from "node:stream";
+
+class NodeFileSystem {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  resolve(relativePath) {
+    return nodePath.join(this.basePath, relativePath);
+  }
+  async exists(relativePath) {
+    return fs6.existsSync(this.resolve(relativePath));
+  }
+  async readFile(relativePath) {
+    return fs6.readFileSync(this.resolve(relativePath), "utf-8");
+  }
+  async readDir(relativePath) {
+    return fs6.readdirSync(this.resolve(relativePath));
+  }
+  async isDirectory(relativePath) {
+    const fullPath = this.resolve(relativePath);
+    if (!fs6.existsSync(fullPath))
+      return false;
+    return fs6.statSync(fullPath).isDirectory();
+  }
+}
+function createCaptureStream() {
+  let output = "";
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      output += chunk.toString();
+      callback();
+    }
+  });
+  return { stream, getOutput: () => output };
+}
+
+class FileNotFoundError extends Error {
+  path;
+  constructor(path9, message) {
+    super(message ?? `File not found: ${path9}`);
+    this.path = path9;
+    this.name = "FileNotFoundError";
+  }
+}
 
+class SandboxFileSystem {
+  sandbox;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  async exists(path9) {
+    const result = await this.sandbox.runCommand({
+      cmd: "test",
+      args: ["-e", path9]
+    });
+    return result.exitCode === 0;
+  }
+  async readFile(path9) {
+    const exists = await this.exists(path9);
+    if (!exists) {
+      throw new FileNotFoundError(path9);
+    }
+    const capture = createCaptureStream();
+    const result = await this.sandbox.runCommand({
+      cmd: "cat",
+      args: [path9],
+      stdout: capture.stream
+    });
+    if (result.exitCode !== 0) {
+      throw new FileNotFoundError(path9, `Failed to read file: ${path9}`);
+    }
+    return capture.getOutput();
+  }
+  async readDir(path9) {
+    const capture = createCaptureStream();
+    const result = await this.sandbox.runCommand({
+      cmd: "ls",
+      args: ["-1", path9],
+      stdout: capture.stream
+    });
+    if (result.exitCode !== 0) {
+      return [];
+    }
+    return capture.getOutput().split(`
+`).filter(Boolean);
+  }
+  async isDirectory(path9) {
+    const result = await this.sandbox.runCommand({
+      cmd: "test",
+      args: ["-d", path9]
+    });
+    return result.exitCode === 0;
+  }
+}
 // src/detect/monorepo.ts
-async function detectMonorepo(fs6) {
-  const pkgJson = await readPackageJson(fs6, ".");
+async function detectMonorepo(fs7) {
+  const pkgJson = await readPackageJson(fs7, ".");
   if (pkgJson?.workspaces) {
     const patterns = extractWorkspacePatterns(pkgJson.workspaces);
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson.name, pkgJson.private);
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson.name, pkgJson.private);
     return {
       isMonorepo: packages.length > 0,
       type: "npm-workspaces",
@@ -4486,10 +4684,10 @@ async function detectMonorepo(fs6) {
       packages
     };
   }
-  if (await fs6.exists("pnpm-workspace.yaml")) {
-    const content = await fs6.readFile("pnpm-workspace.yaml");
+  if (await fs7.exists("pnpm-workspace.yaml")) {
+    const content = await fs7.readFile("pnpm-workspace.yaml");
     const patterns = parsePnpmWorkspace(content);
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson?.name, pkgJson?.private);
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson?.name, pkgJson?.private);
     return {
       isMonorepo: packages.length > 0,
       type: "pnpm-workspaces",
@@ -4497,10 +4695,10 @@ async function detectMonorepo(fs6) {
       packages
     };
   }
-  if (await fs6.exists("lerna.json")) {
-    const lerna = await safeParseJson(fs6, "lerna.json");
+  if (await fs7.exists("lerna.json")) {
+    const lerna = await safeParseJson(fs7, "lerna.json");
     const patterns = lerna?.packages ?? ["packages/*"];
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson?.name, pkgJson?.private);
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson?.name, pkgJson?.private);
     return {
       isMonorepo: packages.length > 0,
       type: "lerna",
@@ -4574,7 +4772,7 @@ function parsePnpmWorkspace(content) {
   }
   return patterns.length > 0 ? patterns : ["packages/*"];
 }
-async function resolveWorkspacePackages(fs6, patterns, rootPackageName, rootIsPrivate) {
+async function resolveWorkspacePackages(fs7, patterns, rootPackageName, rootIsPrivate) {
   const packages = [];
   const seen = new Set;
   if (rootPackageName && !rootIsPrivate && rootPackageName !== "root") {
@@ -4596,18 +4794,18 @@ async function resolveWorkspacePackages(fs6, patterns, rootPackageName, rootIsPr
   }
   dirsToScan.add("packages");
   for (const dir of dirsToScan) {
-    if (!await fs6.exists(dir))
+    if (!await fs7.exists(dir))
       continue;
-    if (!await fs6.isDirectory(dir))
+    if (!await fs7.isDirectory(dir))
       continue;
-    const subdirs = await fs6.readDir(dir);
+    const subdirs = await fs7.readDir(dir);
     for (const subdir of subdirs) {
       const pkgPath = `${dir}/${subdir}`;
       const pkgJsonPath = `${pkgPath}/package.json`;
-      if (!await fs6.exists(pkgJsonPath))
+      if (!await fs7.exists(pkgJsonPath))
         continue;
       try {
-        const content = await fs6.readFile(pkgJsonPath);
+        const content = await fs7.readFile(pkgJsonPath);
         const pkg = JSON.parse(content);
         if (pkg.name && !seen.has(pkg.name)) {
           seen.add(pkg.name);
@@ -4634,290 +4832,24 @@ function formatPackageList(packages, limit = 10) {
   return lines.join(`
 `);
 }
-
-// src/resolve/index.ts
-async function resolveTarget(fs6, options) {
-  let targetDir = options.cwd;
-  let packageInfo;
-  if (options.package) {
-    const mono = await detectMonorepo(fs6);
-    if (!mono.isMonorepo) {
-      throw new Error("Not a monorepo. Remove --package flag for single-package repos.");
+// src/detect/package-manager.ts
+var PM_CONFIGS = {
+  pnpm: {
+    lockfiles: ["pnpm-lock.yaml"],
+    info: {
+      name: "pnpm",
+      lockfile: "pnpm-lock.yaml",
+      installArgs: ["install", "--frozen-lockfile"],
+      runPrefix: ["pnpm"]
     }
-    const pkg = findPackageByName(mono.packages, options.package);
-    if (!pkg) {
-      const available = mono.packages.map((p) => p.name).join(", ");
-      throw new Error(`Package "${options.package}" not found. Available: ${available}`);
-    }
-    targetDir = path9.join(options.cwd, pkg.path);
-    packageInfo = pkg;
-  }
-  let entryFile;
-  let entryPointInfo;
-  if (!options.entry) {
-    entryPointInfo = await detectEntryPoint(fs6, getRelativePath(options.cwd, targetDir));
-    entryFile = path9.join(targetDir, entryPointInfo.path);
-  } else {
-    const explicitPath = path9.resolve(targetDir, options.entry);
-    const isDirectory = await isDir(fs6, getRelativePath(options.cwd, explicitPath));
-    if (isDirectory) {
-      targetDir = explicitPath;
-      entryPointInfo = await detectEntryPoint(fs6, getRelativePath(options.cwd, explicitPath));
-      entryFile = path9.join(explicitPath, entryPointInfo.path);
-    } else {
-      entryFile = explicitPath;
-      entryPointInfo = {
-        path: options.entry,
-        source: "explicit",
-        isDeclarationOnly: options.entry.endsWith(".d.ts")
-      };
-    }
-  }
-  return {
-    targetDir,
-    entryFile,
-    packageInfo,
-    entryPointInfo
-  };
-}
-function getRelativePath(base, target) {
-  if (base === target)
-    return ".";
-  const rel = path9.relative(base, target);
-  return rel || ".";
-}
-async function isDir(fs6, relativePath) {
-  const hasPackageJson = await fs6.exists(path9.join(relativePath, "package.json"));
-  if (hasPackageJson)
-    return true;
-  const commonEntryFiles = ["index.ts", "index.tsx", "src/index.ts", "main.ts"];
-  for (const entry of commonEntryFiles) {
-    if (await fs6.exists(path9.join(relativePath, entry))) {
-      return true;
-    }
-  }
-  return !path9.extname(relativePath);
-}
-// src/detect/build.ts
-var BUILD_SCRIPT_NAMES = new Set([
-  "build",
-  "compile",
-  "tsc",
-  "bundle",
-  "prepare",
-  "prepublish",
-  "prepublishOnly"
-]);
-var BUILD_SCRIPT_PREFIXES = ["build:", "compile:", "bundle:"];
-var BUILD_TOOL_PATTERNS = [
-  "tsc",
-  "esbuild",
-  "rollup",
-  "webpack",
-  "vite build",
-  "parcel build",
-  "swc",
-  "tsup",
-  "unbuild",
-  "bunup",
-  "pkgroll",
-  "microbundle",
-  "babel",
-  "ncc build"
-];
-async function detectBuildInfo(fs6, packagePath = ".") {
-  const pkgJson = await readPackageJson(fs6, packagePath);
-  const scripts = pkgJson?.scripts ?? {};
-  const scriptNames = Object.keys(scripts);
-  const buildScriptsByName = scriptNames.filter((name) => BUILD_SCRIPT_NAMES.has(name) || BUILD_SCRIPT_PREFIXES.some((prefix) => name.startsWith(prefix)));
-  const buildScriptsByContent = scriptNames.filter((name) => {
-    if (buildScriptsByName.includes(name))
-      return false;
-    const content = scripts[name] ?? "";
-    return BUILD_TOOL_PATTERNS.some((tool) => content.includes(tool) && !content.includes(`${tool}-`));
-  });
-  const buildScripts = [...new Set([...buildScriptsByName, ...buildScriptsByContent])];
-  const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
-  const hasTsConfig = await fs6.exists(tsconfigPath);
-  const hasTsDep = pkgJson?.devDependencies?.typescript !== undefined || pkgJson?.dependencies?.typescript !== undefined;
-  const hasTypeScript = hasTsConfig || hasTsDep;
-  const wasm = await detectWasmProject(fs6, packagePath, pkgJson);
-  const napi = detectNapiProject(pkgJson);
-  return {
-    scripts: buildScripts,
-    hasBuildScript: buildScripts.length > 0,
-    hasTypeScript,
-    exoticIndicators: { wasm, napi }
-  };
-}
-var WASM_PACKAGES = new Set([
-  "wasm-pack",
-  "@aspect/wasm-pack",
-  "@aspect-build/wasm-pack",
-  "@aspect/rules_js",
-  "wasm-bindgen",
-  "@aspect/aspect-cli"
-]);
-async function detectWasmProject(fs6, packagePath, pkgJson) {
-  const pkgCargoPath = packagePath === "." ? "Cargo.toml" : `${packagePath}/Cargo.toml`;
-  if (await fs6.exists(pkgCargoPath))
-    return true;
-  if (packagePath !== "." && await fs6.exists("Cargo.toml"))
-    return true;
-  if (pkgJson) {
-    const deps = Object.keys({
-      ...pkgJson.dependencies ?? {},
-      ...pkgJson.devDependencies ?? {}
-    });
-    if (deps.some((dep) => WASM_PACKAGES.has(dep))) {
-      return true;
-    }
-  }
-  return false;
-}
-var NAPI_PACKAGES = new Set([
-  "@napi-rs/cli",
-  "@aspect/napi-cli",
-  "napi",
-  "napi-build",
-  "napi-rs",
-  "neon",
-  "@aspect/neon-cli"
-]);
-function detectNapiProject(pkgJson) {
-  if (!pkgJson)
-    return false;
-  const deps = Object.keys({
-    ...pkgJson.dependencies ?? {},
-    ...pkgJson.devDependencies ?? {}
-  });
-  return deps.some((dep) => NAPI_PACKAGES.has(dep) || dep.includes("@aspect/napi"));
-}
-function getPrimaryBuildScript(buildInfo) {
-  if (buildInfo.scripts.includes("build"))
-    return "build";
-  if (buildInfo.scripts.includes("compile"))
-    return "compile";
-  if (buildInfo.scripts.includes("tsc"))
-    return "tsc";
-  return buildInfo.scripts[0] ?? null;
-}
-// src/detect/filesystem.ts
-import * as fs6 from "node:fs";
-import * as nodePath from "node:path";
-import { Writable } from "node:stream";
-
-class NodeFileSystem {
-  basePath;
-  constructor(basePath) {
-    this.basePath = basePath;
-  }
-  resolve(relativePath) {
-    return nodePath.join(this.basePath, relativePath);
-  }
-  async exists(relativePath) {
-    return fs6.existsSync(this.resolve(relativePath));
-  }
-  async readFile(relativePath) {
-    return fs6.readFileSync(this.resolve(relativePath), "utf-8");
-  }
-  async readDir(relativePath) {
-    return fs6.readdirSync(this.resolve(relativePath));
-  }
-  async isDirectory(relativePath) {
-    const fullPath = this.resolve(relativePath);
-    if (!fs6.existsSync(fullPath))
-      return false;
-    return fs6.statSync(fullPath).isDirectory();
-  }
-}
-function createCaptureStream() {
-  let output = "";
-  const stream = new Writable({
-    write(chunk, _encoding, callback) {
-      output += chunk.toString();
-      callback();
-    }
-  });
-  return { stream, getOutput: () => output };
-}
-
-class FileNotFoundError extends Error {
-  path;
-  constructor(path10, message) {
-    super(message ?? `File not found: ${path10}`);
-    this.path = path10;
-    this.name = "FileNotFoundError";
-  }
-}
-
-class SandboxFileSystem {
-  sandbox;
-  constructor(sandbox) {
-    this.sandbox = sandbox;
-  }
-  async exists(path10) {
-    const result = await this.sandbox.runCommand({
-      cmd: "test",
-      args: ["-e", path10]
-    });
-    return result.exitCode === 0;
-  }
-  async readFile(path10) {
-    const exists = await this.exists(path10);
-    if (!exists) {
-      throw new FileNotFoundError(path10);
-    }
-    const capture = createCaptureStream();
-    const result = await this.sandbox.runCommand({
-      cmd: "cat",
-      args: [path10],
-      stdout: capture.stream
-    });
-    if (result.exitCode !== 0) {
-      throw new FileNotFoundError(path10, `Failed to read file: ${path10}`);
-    }
-    return capture.getOutput();
-  }
-  async readDir(path10) {
-    const capture = createCaptureStream();
-    const result = await this.sandbox.runCommand({
-      cmd: "ls",
-      args: ["-1", path10],
-      stdout: capture.stream
-    });
-    if (result.exitCode !== 0) {
-      return [];
-    }
-    return capture.getOutput().split(`
-`).filter(Boolean);
-  }
-  async isDirectory(path10) {
-    const result = await this.sandbox.runCommand({
-      cmd: "test",
-      args: ["-d", path10]
-    });
-    return result.exitCode === 0;
-  }
-}
-// src/detect/package-manager.ts
-var PM_CONFIGS = {
-  pnpm: {
-    lockfiles: ["pnpm-lock.yaml"],
-    info: {
-      name: "pnpm",
-      lockfile: "pnpm-lock.yaml",
-      installArgs: ["install", "--frozen-lockfile"],
-      runPrefix: ["pnpm"]
-    }
-  },
-  bun: {
-    lockfiles: ["bun.lock", "bun.lockb"],
-    info: {
-      name: "bun",
-      lockfile: "bun.lock",
-      installArgs: ["install", "--frozen-lockfile"],
-      runPrefix: ["bun"]
+  },
+  bun: {
+    lockfiles: ["bun.lock", "bun.lockb"],
+    info: {
+      name: "bun",
+      lockfile: "bun.lock",
+      installArgs: ["install", "--frozen-lockfile"],
+      runPrefix: ["bun"]
     }
   },
   yarn: {
@@ -5019,6 +4951,70 @@ async function analyzeProject(fs7, options = {}) {
   ]);
   return { packageManager, monorepo, entryPoint, build };
 }
+// src/resolve/index.ts
+import * as path9 from "node:path";
+async function resolveTarget(fs7, options) {
+  let targetDir = options.cwd;
+  let packageInfo;
+  if (options.package) {
+    const mono = await detectMonorepo(fs7);
+    if (!mono.isMonorepo) {
+      throw new Error("Not a monorepo. Remove --package flag for single-package repos.");
+    }
+    const pkg = findPackageByName(mono.packages, options.package);
+    if (!pkg) {
+      const available = mono.packages.map((p) => p.name).join(", ");
+      throw new Error(`Package "${options.package}" not found. Available: ${available}`);
+    }
+    targetDir = path9.join(options.cwd, pkg.path);
+    packageInfo = pkg;
+  }
+  let entryFile;
+  let entryPointInfo;
+  if (!options.entry) {
+    entryPointInfo = await detectEntryPoint(fs7, getRelativePath(options.cwd, targetDir));
+    entryFile = path9.join(targetDir, entryPointInfo.path);
+  } else {
+    const explicitPath = path9.resolve(targetDir, options.entry);
+    const isDirectory = await isDir(fs7, getRelativePath(options.cwd, explicitPath));
+    if (isDirectory) {
+      targetDir = explicitPath;
+      entryPointInfo = await detectEntryPoint(fs7, getRelativePath(options.cwd, explicitPath));
+      entryFile = path9.join(explicitPath, entryPointInfo.path);
+    } else {
+      entryFile = explicitPath;
+      entryPointInfo = {
+        path: options.entry,
+        source: "explicit",
+        isDeclarationOnly: options.entry.endsWith(".d.ts")
+      };
+    }
+  }
+  return {
+    targetDir,
+    entryFile,
+    packageInfo,
+    entryPointInfo
+  };
+}
+function getRelativePath(base, target) {
+  if (base === target)
+    return ".";
+  const rel = path9.relative(base, target);
+  return rel || ".";
+}
+async function isDir(fs7, relativePath) {
+  const hasPackageJson = await fs7.exists(path9.join(relativePath, "package.json"));
+  if (hasPackageJson)
+    return true;
+  const commonEntryFiles = ["index.ts", "index.tsx", "src/index.ts", "main.ts"];
+  for (const entry of commonEntryFiles) {
+    if (await fs7.exists(path9.join(relativePath, entry))) {
+      return true;
+    }
+  }
+  return !path9.extname(relativePath);
+}
 // src/examples/types.ts
 var ALL_VALIDATIONS = ["presence", "typecheck", "run"];
 var VALIDATION_INFO = {