@tanstack/intent 0.0.14 → 0.0.20

package/dist/scanner-DVepyEwz.mjs

@@ -0,0 +1,365 @@
+import { a as parseFrontmatter, i as listNodeModulesPackageDirs, o as resolveDepDir, r as getDeps, t as detectGlobalNodeModules } from "./utils-BfjM1mQe.mjs";
+import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns } from "./setup-mGV2dZrq.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+
+//#region src/scanner.ts
+function detectPackageManager(root) {
+	if (existsSync(join(root, ".pnp.cjs")) || existsSync(join(root, ".pnp.js"))) throw new Error("Yarn PnP is not yet supported. Add `nodeLinker: node-modules` to your .yarnrc.yml to use intent.");
+	if (existsSync(join(root, "deno.json")) && !existsSync(join(root, "node_modules"))) throw new Error("Deno without node_modules is not yet supported. Add `\"nodeModulesDir\": \"auto\"` to your deno.json to use intent.");
+	const dirsToCheck = [root];
+	const wsRoot = findWorkspaceRoot(root);
+	if (wsRoot && wsRoot !== root) dirsToCheck.push(wsRoot);
+	for (const dir of dirsToCheck) {
+		if (existsSync(join(dir, "pnpm-lock.yaml"))) return "pnpm";
+		if (existsSync(join(dir, "bun.lockb")) || existsSync(join(dir, "bun.lock"))) return "bun";
+		if (existsSync(join(dir, "yarn.lock"))) return "yarn";
+		if (existsSync(join(dir, "package-lock.json"))) return "npm";
+	}
+	return "unknown";
+}
+function validateIntentField(_pkgName, intent) {
+	if (!intent || typeof intent !== "object") return null;
+	const pb = intent;
+	if (pb.version !== 1) return null;
+	if (typeof pb.repo !== "string" || !pb.repo) return null;
+	if (typeof pb.docs !== "string" || !pb.docs) return null;
+	const requires = Array.isArray(pb.requires) ? pb.requires.filter((r) => typeof r === "string") : void 0;
+	return {
+		version: 1,
+		repo: pb.repo,
+		docs: pb.docs,
+		requires
+	};
+}
+/**
+* Derive an IntentConfig from standard package.json fields when no explicit
+* `intent` field is present. A package with a `skills/` directory signals
+* intent support; `repo` and `docs` are derived from `repository` and
+* `homepage`.
+*/
+function deriveIntentConfig(pkgJson) {
+	let repo = null;
+	if (typeof pkgJson.repository === "string") repo = pkgJson.repository;
+	else if (pkgJson.repository && typeof pkgJson.repository === "object" && typeof pkgJson.repository.url === "string") {
+		repo = pkgJson.repository.url;
+		repo = repo.replace(/^git\+/, "").replace(/\.git$/, "").replace(/^https?:\/\/github\.com\//, "");
+	}
+	const docs = typeof pkgJson.homepage === "string" ? pkgJson.homepage : void 0;
+	if (!repo) return null;
+	const intentPartial = pkgJson.intent;
+	const requires = intentPartial && Array.isArray(intentPartial.requires) ? intentPartial.requires.filter((r) => typeof r === "string") : void 0;
+	return {
+		version: 1,
+		repo,
+		docs: docs ?? "",
+		requires
+	};
+}
+function discoverSkills(skillsDir, _baseName) {
+	const skills = [];
+	function walk(dir) {
+		let entries;
+		try {
+			entries = readdirSync(dir, {
+				withFileTypes: true,
+				encoding: "utf8"
+			});
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const childDir = join(dir, entry.name);
+			const skillFile = join(childDir, "SKILL.md");
+			if (existsSync(skillFile)) {
+				const fm = parseFrontmatter(skillFile);
+				const relName = relative(skillsDir, childDir).split(sep).join("/");
+				const desc = typeof fm?.description === "string" ? fm.description.replace(/\s+/g, " ").trim() : "";
+				skills.push({
+					name: typeof fm?.name === "string" ? fm.name : relName,
+					path: skillFile,
+					description: desc,
+					type: typeof fm?.type === "string" ? fm.type : void 0,
+					framework: typeof fm?.framework === "string" ? fm.framework : void 0
+				});
+				walk(childDir);
+			}
+		}
+	}
+	walk(skillsDir);
+	return skills;
+}
+function topoSort(packages) {
+	const byName = new Map(packages.map((p) => [p.name, p]));
+	const visited = /* @__PURE__ */ new Set();
+	const sorted = [];
+	function visit(name) {
+		if (visited.has(name)) return;
+		visited.add(name);
+		const pkg = byName.get(name);
+		if (!pkg) return;
+		for (const dep of pkg.intent.requires ?? []) visit(dep);
+		sorted.push(pkg);
+	}
+	for (const pkg of packages) visit(pkg.name);
+	return sorted;
+}
+function getPackageDepth(packageRoot, projectRoot) {
+	return relative(projectRoot, packageRoot).split(sep).length;
+}
+function parseSemver(version) {
+	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+	if (!match) return null;
+	const prerelease = match[4] ? match[4].split(".").map((identifier) => {
+		return /^\d+$/.test(identifier) ? Number(identifier) : identifier;
+	}) : [];
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		prerelease
+	};
+}
+function comparePrereleaseIdentifiers(a, b) {
+	if (a === void 0) return b === void 0 ? 0 : 1;
+	if (b === void 0) return -1;
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	if (typeof a === "number") return -1;
+	if (typeof b === "number") return 1;
+	return a.localeCompare(b);
+}
+function comparePackageVersions(a, b) {
+	const parsedA = parseSemver(a);
+	const parsedB = parseSemver(b);
+	if (!parsedA || !parsedB) {
+		if (parsedA) return 1;
+		if (parsedB) return -1;
+		return 0;
+	}
+	for (const key of [
+		"major",
+		"minor",
+		"patch"
+	]) {
+		const diff = parsedA[key] - parsedB[key];
+		if (diff !== 0) return diff;
+	}
+	const length = Math.max(parsedA.prerelease.length, parsedB.prerelease.length);
+	for (let i = 0; i < length; i++) {
+		const diff = comparePrereleaseIdentifiers(parsedA.prerelease[i], parsedB.prerelease[i]);
+		if (diff !== 0) return diff;
+	}
+	return 0;
+}
+function formatVariantWarning(name, variants, chosen) {
+	const uniqueVersions = new Set(variants.map((variant) => variant.version));
+	if (uniqueVersions.size <= 1) return null;
+	const details = variants.map((variant) => `${variant.version} at ${variant.packageRoot}`).join(", ");
+	return `Found ${variants.length} installed variants of ${name} across ${uniqueVersions.size} versions (${details}). Using ${chosen.version} from ${chosen.packageRoot}.`;
+}
+function toVersionConflict(packageName, variants, chosen) {
+	if (new Set(variants.map((variant) => variant.version)).size <= 1) return null;
+	return {
+		packageName,
+		chosen: {
+			version: chosen.version,
+			packageRoot: chosen.packageRoot
+		},
+		variants
+	};
+}
+async function scanForIntents(root) {
+	const projectRoot = root ?? process.cwd();
+	const packageManager = detectPackageManager(projectRoot);
+	const nodeModulesDir = join(projectRoot, "node_modules");
+	const explicitGlobalNodeModules = process.env.INTENT_GLOBAL_NODE_MODULES?.trim() || null;
+	const packages = [];
+	const warnings = [];
+	const conflicts = [];
+	const nodeModules = {
+		local: {
+			path: nodeModulesDir,
+			detected: true,
+			exists: existsSync(nodeModulesDir),
+			scanned: false
+		},
+		global: {
+			path: explicitGlobalNodeModules,
+			detected: Boolean(explicitGlobalNodeModules),
+			exists: explicitGlobalNodeModules ? existsSync(explicitGlobalNodeModules) : false,
+			scanned: false,
+			source: explicitGlobalNodeModules ? "INTENT_GLOBAL_NODE_MODULES" : void 0
+		}
+	};
+	const packageIndexes = /* @__PURE__ */ new Map();
+	const packageJsonCache = /* @__PURE__ */ new Map();
+	const packageVariants = /* @__PURE__ */ new Map();
+	function rememberVariant(pkg) {
+		let variants = packageVariants.get(pkg.name);
+		if (!variants) {
+			variants = /* @__PURE__ */ new Map();
+			packageVariants.set(pkg.name, variants);
+		}
+		variants.set(pkg.packageRoot, {
+			version: pkg.version,
+			packageRoot: pkg.packageRoot
+		});
+	}
+	function ensureGlobalNodeModules() {
+		if (!nodeModules.global.path && !explicitGlobalNodeModules) {
+			const detected = detectGlobalNodeModules(packageManager);
+			nodeModules.global.path = detected.path;
+			nodeModules.global.source = detected.source;
+			nodeModules.global.detected = Boolean(detected.path);
+			nodeModules.global.exists = detected.path ? existsSync(detected.path) : false;
+		}
+	}
+	function readPkgJson(dirPath) {
+		if (packageJsonCache.has(dirPath)) return packageJsonCache.get(dirPath) ?? null;
+		try {
+			const pkgJson = JSON.parse(readFileSync(join(dirPath, "package.json"), "utf8"));
+			packageJsonCache.set(dirPath, pkgJson);
+			return pkgJson;
+		} catch {
+			packageJsonCache.set(dirPath, null);
+			return null;
+		}
+	}
+	function scanTarget(target) {
+		if (!target.path || !target.exists || target.scanned) return;
+		target.scanned = true;
+		for (const dirPath of listNodeModulesPackageDirs(target.path)) tryRegister(dirPath, "unknown");
+	}
+	/**
+	* Try to register a package with a skills/ directory. Reads its
+	* package.json, validates intent config, discovers skills, and pushes
+	* to `packages`. Returns true if the package was registered.
+	*/
+	function tryRegister(dirPath, fallbackName) {
+		const skillsDir = join(dirPath, "skills");
+		if (!existsSync(skillsDir)) return false;
+		const pkgJson = readPkgJson(dirPath);
+		if (!pkgJson) {
+			warnings.push(`Could not read package.json for ${dirPath}`);
+			return false;
+		}
+		const name = typeof pkgJson.name === "string" ? pkgJson.name : fallbackName;
+		const version = typeof pkgJson.version === "string" ? pkgJson.version : "0.0.0";
+		const intent = validateIntentField(name, pkgJson.intent) ?? deriveIntentConfig(pkgJson);
+		if (!intent) {
+			warnings.push(`${name} has a skills/ directory but could not determine repo/docs from package.json (add a "repository" field or explicit "intent" config)`);
+			return false;
+		}
+		const candidate = {
+			name,
+			version,
+			intent,
+			skills: discoverSkills(skillsDir, name),
+			packageRoot: dirPath
+		};
+		const existingIndex = packageIndexes.get(name);
+		if (existingIndex === void 0) {
+			rememberVariant(candidate);
+			packageIndexes.set(name, packages.push(candidate) - 1);
+			return true;
+		}
+		const existing = packages[existingIndex];
+		if (existing.packageRoot === candidate.packageRoot) return false;
+		rememberVariant(existing);
+		rememberVariant(candidate);
+		const existingDepth = getPackageDepth(existing.packageRoot, projectRoot);
+		const candidateDepth = getPackageDepth(candidate.packageRoot, projectRoot);
+		if (candidateDepth < existingDepth || candidateDepth === existingDepth && comparePackageVersions(candidate.version, existing.version) > 0) packages[existingIndex] = candidate;
+		return true;
+	}
+	scanTarget(nodeModules.local);
+	const walkVisited = /* @__PURE__ */ new Set();
+	function walkDeps(pkgDir, pkgName) {
+		if (walkVisited.has(pkgDir)) return;
+		walkVisited.add(pkgDir);
+		const pkgJson = readPkgJson(pkgDir);
+		if (!pkgJson) {
+			warnings.push(`Could not read package.json for ${pkgName} (skipping dependency walk)`);
+			return;
+		}
+		for (const depName of getDeps(pkgJson)) {
+			const depDir = resolveDepDir(depName, pkgDir);
+			if (!depDir || walkVisited.has(depDir)) continue;
+			tryRegister(depDir, depName);
+			walkDeps(depDir, depName);
+		}
+	}
+	function walkKnownPackages() {
+		for (const pkg of [...packages]) walkDeps(pkg.packageRoot, pkg.name);
+	}
+	function walkProjectDeps() {
+		let projectPkg = null;
+		try {
+			projectPkg = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf8"));
+		} catch (err) {
+			if (!(err && typeof err === "object" && "code" in err && err.code === "ENOENT")) warnings.push(`Could not read project package.json: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (!projectPkg) return;
+		walkDepsFromPkgJson(projectPkg, projectRoot, true);
+	}
+	/** Resolve and walk deps listed in a package.json. */
+	function walkDepsFromPkgJson(pkgJson, fromDir, includeDevDeps = false) {
+		for (const depName of getDeps(pkgJson, includeDevDeps)) {
+			const depDir = resolveDepDir(depName, fromDir);
+			if (depDir && !walkVisited.has(depDir)) {
+				tryRegister(depDir, depName);
+				walkDeps(depDir, depName);
+			}
+		}
+	}
+	/**
+	* In monorepos, discover workspace packages and walk their deps.
+	* Handles pnpm monorepos (workspace-specific node_modules) and ensures
+	* transitive skills packages are found through workspace package dependencies.
+	*/
+	function walkWorkspacePackages() {
+		const workspacePatterns = readWorkspacePatterns(projectRoot);
+		if (!workspacePatterns) return;
+		for (const wsDir of resolveWorkspacePackages(projectRoot, workspacePatterns)) {
+			const wsNodeModules = join(wsDir, "node_modules");
+			if (existsSync(wsNodeModules)) for (const dirPath of listNodeModulesPackageDirs(wsNodeModules)) tryRegister(dirPath, "unknown");
+			const wsPkg = readPkgJson(wsDir);
+			if (wsPkg) walkDepsFromPkgJson(wsPkg, wsDir);
+		}
+	}
+	walkWorkspacePackages();
+	walkKnownPackages();
+	walkProjectDeps();
+	if (explicitGlobalNodeModules || packages.length === 0 || !nodeModules.local.exists) {
+		ensureGlobalNodeModules();
+		scanTarget(nodeModules.global);
+		walkKnownPackages();
+		walkProjectDeps();
+	}
+	if (!nodeModules.local.exists && !nodeModules.global.exists) return {
+		packageManager,
+		packages,
+		warnings,
+		conflicts,
+		nodeModules
+	};
+	for (const pkg of packages) {
+		const variants = packageVariants.get(pkg.name);
+		if (!variants) continue;
+		const conflict = toVersionConflict(pkg.name, [...variants.values()], pkg);
+		if (conflict) conflicts.push(conflict);
+		const warning = formatVariantWarning(pkg.name, [...variants.values()], pkg);
+		if (warning) warnings.push(warning);
+	}
+	return {
+		packageManager,
+		packages: topoSort(packages),
+		warnings,
+		conflicts,
+		nodeModules
+	};
+}
+
+//#endregion
+export { scanForIntents as t };

package/dist/setup-B-zdCBu4.d.mts

@@ -0,0 +1,36 @@
+//#region src/setup.d.ts
+interface AddLibraryBinResult {
+  shim: string | null;
+  skipped: string | null;
+}
+interface EditPackageJsonResult {
+  added: Array<string>;
+  alreadyPresent: Array<string>;
+}
+interface SetupGithubActionsResult {
+  workflows: Array<string>;
+  skipped: Array<string>;
+}
+interface MonorepoResult<T> {
+  package: string;
+  result: T;
+}
+declare function runAddLibraryBin(root: string): AddLibraryBinResult;
+declare function runEditPackageJson(root: string): EditPackageJsonResult;
+declare function readWorkspacePatterns(root: string): Array<string> | null;
+/**
+ * Resolve workspace glob patterns to actual package directories.
+ * Handles simple patterns like "packages/*" and "packages/**".
+ * Each resolved directory must contain a package.json.
+ */
+declare function resolveWorkspacePackages(root: string, patterns: Array<string>): Array<string>;
+declare function findWorkspaceRoot(start: string): string | null;
+/**
+ * Find workspace packages that contain at least one SKILL.md file.
+ */
+declare function findPackagesWithSkills(root: string): Array<string>;
+declare function runEditPackageJsonAll(root: string): Array<MonorepoResult<EditPackageJsonResult>> | EditPackageJsonResult;
+declare function runAddLibraryBinAll(root: string): Array<MonorepoResult<AddLibraryBinResult>> | AddLibraryBinResult;
+declare function runSetupGithubActions(root: string, metaDir: string): SetupGithubActionsResult;
+//#endregion
+export { findPackagesWithSkills as a, resolveWorkspacePackages as c, runEditPackageJson as d, runEditPackageJsonAll as f, SetupGithubActionsResult as i, runAddLibraryBin as l, EditPackageJsonResult as n, findWorkspaceRoot as o, runSetupGithubActions as p, MonorepoResult as r, readWorkspacePatterns as s, AddLibraryBinResult as t, runAddLibraryBinAll as u };