@tanstack/intent 0.0.14 → 0.0.20

package/dist/setup-mGV2dZrq.mjs

@@ -0,0 +1,367 @@
+import { n as findSkillFiles } from "./utils-BfjM1mQe.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, join, relative } from "node:path";
+import { parse } from "yaml";
+
+//#region src/setup.ts
+function readPackageJson(root) {
+	const pkgPath = join(root, "package.json");
+	try {
+		return JSON.parse(readFileSync(pkgPath, "utf8"));
+	} catch (err) {
+		if (!(err && typeof err === "object" && "code" in err && err.code === "ENOENT")) console.error(`Warning: could not read ${pkgPath}: ${err instanceof Error ? err.message : err}`);
+		return {};
+	}
+}
+function detectRepo(pkgJson, fallback) {
+	const intent = pkgJson.intent;
+	if (typeof intent?.repo === "string") return intent.repo;
+	if (typeof pkgJson.repository === "string") return pkgJson.repository.replace(/^git\+/, "").replace(/\.git$/, "").replace(/^https?:\/\/github\.com\//, "");
+	if (pkgJson.repository && typeof pkgJson.repository === "object" && typeof pkgJson.repository.url === "string") return pkgJson.repository.url.replace(/^git\+/, "").replace(/\.git$/, "").replace(/^https?:\/\/github\.com\//, "");
+	return fallback;
+}
+function normalizePattern(pattern) {
+	return pattern.endsWith("**") ? pattern : pattern.replace(/\/$/, "") + "/**";
+}
+function buildWatchPaths(root, packageDirs) {
+	const paths = /* @__PURE__ */ new Set();
+	if (existsSync(join(root, "docs"))) paths.add("docs/**");
+	for (const packageDir of packageDirs) {
+		const relDir = relative(root, packageDir).split("\\").join("/");
+		if (existsSync(join(packageDir, "src"))) paths.add(`${relDir}/src/**`);
+		const intent = readPackageJson(packageDir).intent;
+		const docs = typeof intent?.docs === "string" ? intent.docs : "docs/";
+		if (!docs.startsWith("http://") && !docs.startsWith("https://")) paths.add(normalizePattern(join(relDir, docs).split("\\").join("/")));
+	}
+	if (paths.size === 0) {
+		paths.add("packages/*/src/**");
+		paths.add("packages/*/docs/**");
+	}
+	return [...paths].sort().map((path) => `      - '${path}'`).join("\n");
+}
+function detectVars(root, packageDirs) {
+	const pkgJson = readPackageJson(root);
+	const name = typeof pkgJson.name === "string" ? pkgJson.name : "unknown";
+	const docs = typeof pkgJson.intent?.docs === "string" ? pkgJson.intent.docs : "docs/";
+	const repo = detectRepo(pkgJson, name.replace(/^@/, "").replace(/\//, "/"));
+	const isMonorepo = packageDirs !== void 0;
+	const packageLabel = isMonorepo && name === "unknown" ? `${basename(root)} workspace` : name;
+	let srcPath = `packages/${name.replace(/^@[^/]+\//, "")}/src/**`;
+	if (existsSync(join(root, "src"))) srcPath = "src/**";
+	return {
+		PACKAGE_NAME: name,
+		PACKAGE_LABEL: packageLabel,
+		PAYLOAD_PACKAGE: packageLabel,
+		REPO: repo,
+		DOCS_PATH: docs.endsWith("**") ? docs : docs.replace(/\/$/, "") + "/**",
+		SRC_PATH: srcPath,
+		WATCH_PATHS: isMonorepo ? buildWatchPaths(root, packageDirs) : `      - '${docs.endsWith("**") ? docs : docs.replace(/\/$/, "") + "/**"}'\n      - '${srcPath}'`
+	};
+}
+function applyVars(content, vars) {
+	return content.replace(/\{\{PACKAGE_NAME\}\}/g, vars.PACKAGE_NAME).replace(/\{\{PACKAGE_LABEL\}\}/g, vars.PACKAGE_LABEL).replace(/\{\{PAYLOAD_PACKAGE\}\}/g, vars.PAYLOAD_PACKAGE).replace(/\{\{REPO\}\}/g, vars.REPO).replace(/\{\{DOCS_PATH\}\}/g, vars.DOCS_PATH).replace(/\{\{SRC_PATH\}\}/g, vars.SRC_PATH).replace(/\{\{WATCH_PATHS\}\}/g, vars.WATCH_PATHS);
+}
+function copyTemplates(srcDir, destDir, vars) {
+	const copied = [];
+	const skipped = [];
+	if (!existsSync(srcDir)) return {
+		copied,
+		skipped
+	};
+	mkdirSync(destDir, { recursive: true });
+	for (const entry of readdirSync(srcDir)) {
+		const srcPath = join(srcDir, entry);
+		const destPath = join(destDir, entry);
+		if (existsSync(destPath)) {
+			skipped.push(destPath);
+			continue;
+		}
+		let content = readFileSync(srcPath, "utf8");
+		if (vars.WATCH_PATHS.includes("\n")) content = content.replace(/\s+- '?\{\{DOCS_PATH\}\}'?\n\s+- '?\{\{SRC_PATH\}\}'?/, vars.WATCH_PATHS);
+		writeFileSync(destPath, applyVars(content, vars));
+		copied.push(destPath);
+	}
+	return {
+		copied,
+		skipped
+	};
+}
+function getShimContent(ext) {
+	return `#!/usr/bin/env node
+// Auto-generated by @tanstack/intent setup
+// Exposes the intent end-user CLI for consumers of this library.
+// Commit this file, then add to your package.json:
+//   "bin": { "intent": "./bin/intent.${ext}" }
+try {
+  await import('@tanstack/intent/intent-library')
+} catch (e) {
+  if (e?.code === 'ERR_MODULE_NOT_FOUND' || e?.code === 'MODULE_NOT_FOUND') {
+    console.error('@tanstack/intent is not installed.')
+    console.error('')
+    console.error('Install it as a dev dependency:')
+    console.error('  npm add -D @tanstack/intent')
+    console.error('')
+    console.error('Or run directly:')
+    console.error('  npx @tanstack/intent@latest list')
+    process.exit(1)
+  }
+  throw e
+}
+`;
+}
+function detectShimExtension(root) {
+	try {
+		if (JSON.parse(readFileSync(join(root, "package.json"), "utf8")).type === "module") return "js";
+	} catch (err) {
+		if (!(err && typeof err === "object" && "code" in err && err.code === "ENOENT")) console.error(`Warning: could not read package.json: ${err instanceof Error ? err.message : err}`);
+	}
+	return "mjs";
+}
+function findExistingShim(root) {
+	const shimJs = join(root, "bin", "intent.js");
+	if (existsSync(shimJs)) return shimJs;
+	const shimMjs = join(root, "bin", "intent.mjs");
+	if (existsSync(shimMjs)) return shimMjs;
+	return null;
+}
+function runAddLibraryBin(root) {
+	const result = {
+		shim: null,
+		skipped: null
+	};
+	const existingShim = findExistingShim(root);
+	if (existingShim) {
+		result.skipped = existingShim;
+		console.log(`  Already exists: ${existingShim}`);
+		return result;
+	}
+	const ext = detectShimExtension(root);
+	const shimPath = join(root, "bin", `intent.${ext}`);
+	mkdirSync(join(root, "bin"), { recursive: true });
+	writeFileSync(shimPath, getShimContent(ext));
+	result.shim = shimPath;
+	console.log(`✓ Generated intent shim: ${shimPath}`);
+	console.log(`\n  Run \`npx @tanstack/intent edit-package-json\` to wire package.json.`);
+	return result;
+}
+function runEditPackageJson(root) {
+	const result = {
+		added: [],
+		alreadyPresent: []
+	};
+	const pkgPath = join(root, "package.json");
+	if (!existsSync(pkgPath)) {
+		console.error("No package.json found in " + root);
+		process.exitCode = 1;
+		return result;
+	}
+	const raw = readFileSync(pkgPath, "utf8");
+	let pkg;
+	try {
+		pkg = JSON.parse(raw);
+	} catch (err) {
+		const detail = err instanceof SyntaxError ? err.message : String(err);
+		console.error(`Failed to parse ${pkgPath}: ${detail}`);
+		return result;
+	}
+	const indentMatch = raw.match(/^(\s+)"/m);
+	const indentSize = indentMatch?.[1] ? indentMatch[1].length : 2;
+	if (!Array.isArray(pkg.keywords)) pkg.keywords = [];
+	const keywords = pkg.keywords;
+	for (const kw of ["tanstack-intent"]) if (keywords.includes(kw)) result.alreadyPresent.push(`keywords: "${kw}"`);
+	else {
+		keywords.push(kw);
+		result.added.push(`keywords: "${kw}"`);
+	}
+	if (!Array.isArray(pkg.files)) pkg.files = [];
+	const files = pkg.files;
+	const requiredFiles = (() => {
+		let dir = join(root, "..");
+		for (let i = 0; i < 5; i++) {
+			const parentPkg = join(dir, "package.json");
+			if (existsSync(parentPkg)) {
+				try {
+					const parent = JSON.parse(readFileSync(parentPkg, "utf8"));
+					if (Array.isArray(parent.workspaces) || parent.workspaces?.packages) return true;
+				} catch {}
+				return false;
+			}
+			const next = join(dir, "..");
+			if (next === dir) break;
+			dir = next;
+		}
+		return false;
+	})() ? ["skills", "bin"] : [
+		"skills",
+		"bin",
+		"!skills/_artifacts"
+	];
+	for (const entry of requiredFiles) if (files.includes(entry)) result.alreadyPresent.push(`files: "${entry}"`);
+	else {
+		files.push(entry);
+		result.added.push(`files: "${entry}"`);
+	}
+	const existingShim = findExistingShim(root);
+	let ext;
+	if (existingShim) ext = existingShim.endsWith(".mjs") ? "mjs" : "js";
+	else ext = pkg.type === "module" ? "js" : "mjs";
+	const shimRelative = `./bin/intent.${ext}`;
+	if (typeof pkg.bin === "object" && pkg.bin !== null) {
+		const binObj = pkg.bin;
+		if (binObj.intent) result.alreadyPresent.push(`bin.intent`);
+		else {
+			binObj.intent = shimRelative;
+			result.added.push(`bin.intent: "${shimRelative}"`);
+		}
+	} else if (!pkg.bin) {
+		pkg.bin = { intent: shimRelative };
+		result.added.push(`bin.intent: "${shimRelative}"`);
+	} else if (typeof pkg.bin === "string") {
+		const pkgName = typeof pkg.name === "string" ? pkg.name.replace(/^@[^/]+\//, "") : "unknown";
+		pkg.bin = {
+			[pkgName]: pkg.bin,
+			intent: shimRelative
+		};
+		result.added.push(`bin.intent: "${shimRelative}" (converted bin from string to object)`);
+	}
+	writeFileSync(pkgPath, JSON.stringify(pkg, null, indentSize) + "\n");
+	for (const a of result.added) console.log(`✓ Added ${a}`);
+	for (const a of result.alreadyPresent) console.log(`  Already present: ${a}`);
+	return result;
+}
+function readWorkspacePatterns(root) {
+	const pnpmWs = join(root, "pnpm-workspace.yaml");
+	if (existsSync(pnpmWs)) try {
+		const config = parse(readFileSync(pnpmWs, "utf8"));
+		if (Array.isArray(config.packages)) return config.packages;
+	} catch (err) {
+		console.error(`Warning: failed to parse ${pnpmWs}: ${err instanceof Error ? err.message : err}`);
+	}
+	const pkgPath = join(root, "package.json");
+	if (existsSync(pkgPath)) try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+		if (Array.isArray(pkg.workspaces)) return pkg.workspaces;
+		if (Array.isArray(pkg.workspaces?.packages)) return pkg.workspaces.packages;
+	} catch (err) {
+		console.error(`Warning: failed to parse ${pkgPath}: ${err instanceof Error ? err.message : err}`);
+	}
+	return null;
+}
+/**
+* Resolve workspace glob patterns to actual package directories.
+* Handles simple patterns like "packages/*" and "packages/**".
+* Each resolved directory must contain a package.json.
+*/
+function resolveWorkspacePackages(root, patterns) {
+	const dirs = [];
+	for (const pattern of patterns) {
+		const baseDir = join(root, pattern.replace(/\/\*\*?(\/\*)?$/, ""));
+		if (!existsSync(baseDir)) continue;
+		if (pattern.includes("**")) collectPackageDirs(baseDir, dirs);
+		else if (pattern.endsWith("/*")) {
+			let entries;
+			try {
+				entries = readdirSync(baseDir, { withFileTypes: true });
+			} catch {
+				continue;
+			}
+			for (const entry of entries) {
+				if (!entry.isDirectory()) continue;
+				const dir = join(baseDir, entry.name);
+				if (existsSync(join(dir, "package.json"))) dirs.push(dir);
+			}
+		} else {
+			const dir = join(root, pattern);
+			if (existsSync(join(dir, "package.json"))) dirs.push(dir);
+		}
+	}
+	return dirs;
+}
+function collectPackageDirs(dir, result) {
+	if (existsSync(join(dir, "package.json"))) result.push(dir);
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch (err) {
+		console.error(`Warning: could not read directory ${dir}: ${err instanceof Error ? err.message : err}`);
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+		collectPackageDirs(join(dir, entry.name), result);
+	}
+}
+function findWorkspaceRoot(start) {
+	let dir = start;
+	while (true) {
+		if (readWorkspacePatterns(dir)) return dir;
+		const next = join(dir, "..");
+		if (next === dir) return null;
+		dir = next;
+	}
+}
+/**
+* Find workspace packages that contain at least one SKILL.md file.
+*/
+function findPackagesWithSkills(root) {
+	const patterns = readWorkspacePatterns(root);
+	if (!patterns) return [];
+	return resolveWorkspacePackages(root, patterns).filter((dir) => {
+		const skillsDir = join(dir, "skills");
+		return existsSync(skillsDir) && findSkillFiles(skillsDir).length > 0;
+	});
+}
+/**
+* When run from a monorepo root, finds all workspace packages with SKILL.md
+* files and runs the given command on each. Falls back to single-package
+* behavior only when no workspace config is detected. If workspace config
+* exists but no packages have skills, warns and returns empty.
+*/
+function runForEachPackage(root, runOne) {
+	const isMonorepo = readWorkspacePatterns(root) !== null;
+	const pkgsWithSkills = isMonorepo ? findPackagesWithSkills(root) : [];
+	if (!isMonorepo) return runOne(root);
+	if (pkgsWithSkills.length === 0) {
+		console.log("No workspace packages with skills found.");
+		return [];
+	}
+	return pkgsWithSkills.map((pkgDir) => {
+		const rel = relative(root, pkgDir) || ".";
+		console.log(`\n── ${rel} ──`);
+		return {
+			package: rel,
+			result: runOne(pkgDir)
+		};
+	});
+}
+function runEditPackageJsonAll(root) {
+	return runForEachPackage(root, runEditPackageJson);
+}
+function runAddLibraryBinAll(root) {
+	return runForEachPackage(root, runAddLibraryBin);
+}
+function runSetupGithubActions(root, metaDir) {
+	const workspaceRoot = findWorkspaceRoot(root) ?? root;
+	const packageDirs = findPackagesWithSkills(workspaceRoot);
+	const vars = detectVars(workspaceRoot, packageDirs.length > 0 ? packageDirs : void 0);
+	const result = {
+		workflows: [],
+		skipped: []
+	};
+	const { copied, skipped } = copyTemplates(join(metaDir, "templates", "workflows"), join(workspaceRoot, ".github", "workflows"), vars);
+	result.workflows = copied;
+	result.skipped = skipped;
+	for (const f of result.workflows) console.log(`✓ Copied workflow: ${f}`);
+	for (const f of result.skipped) console.log(`  Already exists: ${f}`);
+	if (result.workflows.length === 0 && result.skipped.length === 0) console.log("No templates directory found. Is @tanstack/intent installed?");
+	else if (result.workflows.length > 0) {
+		console.log(`\nTemplate variables applied:`);
+		console.log(`  Package:  ${vars.PACKAGE_LABEL}`);
+		console.log(`  Repo:     ${vars.REPO}`);
+		console.log(`  Mode:     ${packageDirs.length > 0 ? `monorepo (${packageDirs.length} packages with skills)` : "single package"}`);
+	}
+	return result;
+}
+
+//#endregion
+export { runAddLibraryBin as a, runEditPackageJsonAll as c, resolveWorkspacePackages as i, runSetupGithubActions as l, findWorkspaceRoot as n, runAddLibraryBinAll as o, readWorkspacePatterns as r, runEditPackageJson as s, findPackagesWithSkills as t };

package/dist/setup.d.mts

@@ -1,2 +1,2 @@
-import { a as runEditPackageJson, i as runAddLibraryBin, n as EditPackageJsonResult, o as runSetupGithubActions, r as SetupGithubActionsResult, t as AddLibraryBinResult } from "./setup-CANkTz55.mjs";
-export { AddLibraryBinResult, EditPackageJsonResult, SetupGithubActionsResult, runAddLibraryBin, runEditPackageJson, runSetupGithubActions };
+import { a as findPackagesWithSkills, c as resolveWorkspacePackages, d as runEditPackageJson, f as runEditPackageJsonAll, i as SetupGithubActionsResult, l as runAddLibraryBin, n as EditPackageJsonResult, o as findWorkspaceRoot, p as runSetupGithubActions, r as MonorepoResult, s as readWorkspacePatterns, t as AddLibraryBinResult, u as runAddLibraryBinAll } from "./setup-B-zdCBu4.mjs";
+export { AddLibraryBinResult, EditPackageJsonResult, MonorepoResult, SetupGithubActionsResult, findPackagesWithSkills, findWorkspaceRoot, readWorkspacePatterns, resolveWorkspacePackages, runAddLibraryBin, runAddLibraryBinAll, runEditPackageJson, runEditPackageJsonAll, runSetupGithubActions };

package/dist/setup.mjs

@@ -1,3 +1,4 @@
-import { n as runEditPackageJson, r as runSetupGithubActions, t as runAddLibraryBin } from "./setup-Nif1-nhS.mjs";
+import "./utils-BfjM1mQe.mjs";
+import { a as runAddLibraryBin, c as runEditPackageJsonAll, i as resolveWorkspacePackages, l as runSetupGithubActions, n as findWorkspaceRoot, o as runAddLibraryBinAll, r as readWorkspacePatterns, s as runEditPackageJson, t as findPackagesWithSkills } from "./setup-mGV2dZrq.mjs";
 
-export { runAddLibraryBin, runEditPackageJson, runSetupGithubActions };
+export { findPackagesWithSkills, findWorkspaceRoot, readWorkspacePatterns, resolveWorkspacePackages, runAddLibraryBin, runAddLibraryBinAll, runEditPackageJson, runEditPackageJsonAll, runSetupGithubActions };

package/dist/{staleness-DJfMKH62.mjs → staleness-DZKvsLVq.mjs}

@@ -1,4 +1,4 @@
-import { r as parseFrontmatter, t as findSkillFiles } from "./utils-CDJzAdjD.mjs";
+import { a as parseFrontmatter, n as findSkillFiles } from "./utils-BfjM1mQe.mjs";
 import { readFileSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 
@@ -22,10 +22,31 @@ async function fetchNpmVersion(packageName) {
 		return null;
 	}
 }
+function isStringRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function parseSyncState(value) {
+	if (!value || typeof value !== "object") return null;
+	const raw = value;
+	const parsed = {};
+	if (typeof raw.library_version === "string") parsed.library_version = raw.library_version;
+	if (raw.skills && typeof raw.skills === "object") {
+		const skills = {};
+		for (const [skillName, skillValue] of Object.entries(raw.skills)) {
+			if (!skillValue || typeof skillValue !== "object") continue;
+			const sourcesSha = skillValue.sources_sha;
+			if (sourcesSha !== void 0 && !isStringRecord(sourcesSha)) continue;
+			skills[skillName] = {};
+			if (sourcesSha) skills[skillName].sources_sha = sourcesSha;
+		}
+		parsed.skills = skills;
+	}
+	return parsed;
+}
 function readSyncState(packageDir) {
 	const statePath = join(packageDir, "skills", "sync-state.json");
 	try {
-		return JSON.parse(readFileSync(statePath, "utf8"));
+		return parseSyncState(JSON.parse(readFileSync(statePath, "utf8")));
 	} catch {
 		return null;
 	}
@@ -37,7 +58,7 @@ async function checkStaleness(packageDir, packageName) {
 		const fm = parseFrontmatter(filePath);
 		const relName = relative(skillsDir, filePath).replace(/[/\\]SKILL\.md$/, "").split(sep).join("/");
 		return {
-			name: fm?.name ?? relName,
+			name: typeof fm?.name === "string" ? fm.name : relName,
 			filePath,
 			libraryVersion: fm?.library_version,
 			sources: Array.isArray(fm?.sources) ? fm.sources : void 0

package/dist/staleness-Dr5-5wj5.mjs

@@ -0,0 +1,4 @@
+import "./utils-BfjM1mQe.mjs";
+import { t as checkStaleness } from "./staleness-DZKvsLVq.mjs";
+
+export { checkStaleness };

package/dist/{types-BmnI8kFB.d.mts → types-ddLtccfV.d.mts}

@@ -3,18 +3,40 @@ interface IntentConfig {
   version: number;
   repo: string;
   docs: string;
-  requires?: string[];
+  requires?: Array<string>;
 }
 interface ScanResult {
   packageManager: 'npm' | 'pnpm' | 'yarn' | 'bun' | 'unknown';
-  packages: IntentPackage[];
-  warnings: string[];
+  packages: Array<IntentPackage>;
+  warnings: Array<string>;
+  conflicts: Array<VersionConflict>;
+  nodeModules: {
+    local: NodeModulesScanTarget;
+    global: NodeModulesScanTarget;
+  };
+}
+interface NodeModulesScanTarget {
+  path: string | null;
+  detected: boolean;
+  exists: boolean;
+  scanned: boolean;
+  source?: string;
 }
 interface IntentPackage {
   name: string;
   version: string;
   intent: IntentConfig;
-  skills: SkillEntry[];
+  skills: Array<SkillEntry>;
+  packageRoot: string;
+}
+interface InstalledVariant {
+  version: string;
+  packageRoot: string;
+}
+interface VersionConflict {
+  packageName: string;
+  chosen: InstalledVariant;
+  variants: Array<InstalledVariant>;
 }
 interface SkillEntry {
   name: string;
@@ -28,11 +50,11 @@ interface StalenessReport {
   currentVersion: string | null;
   skillVersion: string | null;
   versionDrift: 'major' | 'minor' | 'patch' | null;
-  skills: SkillStaleness[];
+  skills: Array<SkillStaleness>;
 }
 interface SkillStaleness {
   name: string;
-  reasons: string[];
+  reasons: Array<string>;
   needsReview: boolean;
 }
 interface FeedbackPayload {
@@ -61,9 +83,10 @@ interface MetaFeedbackPayload {
   suggestions: string;
   userRating: 'good' | 'mixed' | 'bad';
 }
+type FeedbackFrequency = 'always' | 'never' | `every-${number}`;
 interface IntentProjectConfig {
   feedback: {
-    frequency: string;
+    frequency: FeedbackFrequency;
   };
 }
 //#endregion

package/dist/utils-BfjM1mQe.mjs

@@ -0,0 +1,152 @@
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { parse } from "yaml";
+
+//#region src/utils.ts
+/**
+* Recursively find all SKILL.md files under a directory.
+*/
+function findSkillFiles(dir) {
+	const files = [];
+	if (!existsSync(dir)) return files;
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...findSkillFiles(fullPath));
+		else if (entry.name === "SKILL.md") files.push(fullPath);
+	}
+	return files;
+}
+/**
+* Read dependencies and peerDependencies (and optionally devDependencies) from
+* a parsed package.json object.
+*/
+function getDeps(pkgJson, includeDevDeps = false) {
+	const deps = /* @__PURE__ */ new Set();
+	const fields = includeDevDeps ? [
+		"dependencies",
+		"devDependencies",
+		"peerDependencies"
+	] : ["dependencies", "peerDependencies"];
+	for (const field of fields) {
+		const d = pkgJson[field];
+		if (d && typeof d === "object") for (const name of Object.keys(d)) deps.add(name);
+	}
+	return [...deps];
+}
+function listNodeModulesPackageDirs(nodeModulesDir) {
+	if (!existsSync(nodeModulesDir)) return [];
+	let topEntries;
+	try {
+		topEntries = readdirSync(nodeModulesDir, {
+			withFileTypes: true,
+			encoding: "utf8"
+		});
+	} catch {
+		return [];
+	}
+	const packageDirs = [];
+	for (const entry of topEntries) {
+		if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+		const dirPath = join(nodeModulesDir, entry.name);
+		if (entry.name.startsWith("@")) {
+			let scopedEntries;
+			try {
+				scopedEntries = readdirSync(dirPath, {
+					withFileTypes: true,
+					encoding: "utf8"
+				});
+			} catch {
+				continue;
+			}
+			for (const scoped of scopedEntries) {
+				if (!scoped.isDirectory() && !scoped.isSymbolicLink()) continue;
+				packageDirs.push(join(dirPath, scoped.name));
+			}
+		} else if (!entry.name.startsWith(".")) packageDirs.push(dirPath);
+	}
+	return packageDirs;
+}
+function detectGlobalNodeModules(packageManager) {
+	const envPath = process.env.INTENT_GLOBAL_NODE_MODULES?.trim();
+	if (envPath) return {
+		path: envPath,
+		source: "INTENT_GLOBAL_NODE_MODULES"
+	};
+	const commands = [];
+	if (packageManager === "pnpm") commands.push({
+		command: "pnpm",
+		args: ["root", "-g"]
+	});
+	if (packageManager === "yarn") commands.push({
+		command: "yarn",
+		args: ["global", "dir"],
+		transform: (output) => join(output, "node_modules")
+	});
+	commands.push({
+		command: "npm",
+		args: ["root", "-g"]
+	});
+	for (const candidate of commands) try {
+		const output = execFileSync(candidate.command, candidate.args, {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		if (!output) continue;
+		return {
+			path: candidate.transform ? candidate.transform(output) : output,
+			source: `${candidate.command} ${candidate.args.join(" ")}`
+		};
+	} catch {
+		continue;
+	}
+	return { path: null };
+}
+/**
+* Resolve the directory of a dependency by name. Tries createRequire first
+* (handles pnpm symlinks), then falls back to walking up node_modules
+* directories (handles packages with export maps that block ./package.json).
+*/
+function resolveDepDir(depName, parentDir) {
+	try {
+		return dirname(createRequire(join(parentDir, "package.json")).resolve(join(depName, "package.json")));
+	} catch (err) {
+		const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+		if (code && code !== "MODULE_NOT_FOUND" && code !== "ERR_PACKAGE_PATH_NOT_EXPORTED") console.warn(`Warning: could not resolve ${depName} from ${parentDir}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	let dir = parentDir;
+	while (true) {
+		const candidate = join(dir, "node_modules", depName);
+		if (existsSync(join(candidate, "package.json"))) return candidate;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+/**
+* Parse YAML frontmatter from a file. Returns null if no frontmatter or on error.
+*/
+function parseFrontmatter(filePath) {
+	let content;
+	try {
+		content = readFileSync(filePath, "utf8");
+	} catch {
+		return null;
+	}
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!match?.[1]) return null;
+	try {
+		return parse(match[1]);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { parseFrontmatter as a, listNodeModulesPackageDirs as i, findSkillFiles as n, resolveDepDir as o, getDeps as r, detectGlobalNodeModules as t };

package/dist/utils-D7OKi0Rn.mjs

@@ -0,0 +1,3 @@
+import { a as parseFrontmatter, i as listNodeModulesPackageDirs, n as findSkillFiles, o as resolveDepDir, r as getDeps, t as detectGlobalNodeModules } from "./utils-BfjM1mQe.mjs";
+
+export { detectGlobalNodeModules, findSkillFiles, getDeps, listNodeModulesPackageDirs, parseFrontmatter, resolveDepDir };