@tanstack/intent 0.0.27 → 0.0.32

package/dist/scanner-CRZITpcY.mjs

@@ -0,0 +1,6 @@
+import "./utils-COlDcU72.mjs";
+import "./skill-paths-8k9K9y26.mjs";
+import { t as scanForIntents } from "./scanner-DKL8v8is.mjs";
+import "./workspace-patterns-U35B5AO-.mjs";
+
+export { scanForIntents };

package/dist/{scanner-1ZGYK3Qm.mjs → scanner-DKL8v8is.mjs}

@@ -1,8 +1,136 @@
 import { a as parseFrontmatter, i as listNodeModulesPackageDirs, o as resolveDepDir, r as getDeps, s as toPosixPath, t as detectGlobalNodeModules } from "./utils-COlDcU72.mjs";
-import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns } from "./workspace-patterns-BuJMfudb.mjs";
+import { r as rewriteSkillLoadPaths } from "./skill-paths-8k9K9y26.mjs";
+import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns } from "./workspace-patterns-U35B5AO-.mjs";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 
+//#region src/discovery/register.ts
+function isLocalToProject(dirPath, projectRoot) {
+	return dirPath.startsWith(projectRoot + sep) || dirPath.startsWith(projectRoot + "/");
+}
+function createPackageRegistrar(opts) {
+	function scanTarget(target, source = "local") {
+		if (!target.path || !target.exists || target.scanned) return;
+		target.scanned = true;
+		for (const dirPath of listNodeModulesPackageDirs(target.path)) tryRegister(dirPath, "unknown", source);
+	}
+	function tryRegister(dirPath, fallbackName, source = "local") {
+		const skillsDir = join(dirPath, "skills");
+		if (!existsSync(skillsDir)) return false;
+		const pkgJson = opts.readPkgJson(dirPath);
+		if (!pkgJson) {
+			opts.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 = opts.validateIntentField(name, pkgJson.intent) ?? opts.deriveIntentConfig(pkgJson);
+		if (!intent) {
+			opts.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 skills = opts.discoverSkills(skillsDir, name);
+		if (isLocalToProject(dirPath, opts.projectRoot)) rewriteSkillLoadPaths({
+			packageName: name,
+			packageRoot: dirPath,
+			projectRoot: opts.projectRoot,
+			skills
+		});
+		const candidate = {
+			name,
+			version,
+			intent,
+			skills,
+			packageRoot: dirPath,
+			source
+		};
+		const existingIndex = opts.packageIndexes.get(name);
+		if (existingIndex === void 0) {
+			opts.rememberVariant(candidate);
+			opts.packageIndexes.set(name, opts.packages.push(candidate) - 1);
+			return true;
+		}
+		const existing = opts.packages[existingIndex];
+		if (existing.packageRoot === candidate.packageRoot) return false;
+		opts.rememberVariant(existing);
+		opts.rememberVariant(candidate);
+		const existingDepth = opts.getPackageDepth(existing.packageRoot, opts.projectRoot);
+		const candidateDepth = opts.getPackageDepth(candidate.packageRoot, opts.projectRoot);
+		if (candidateDepth < existingDepth || candidateDepth === existingDepth && opts.comparePackageVersions(candidate.version, existing.version) > 0) opts.packages[existingIndex] = candidate;
+		return true;
+	}
+	return {
+		scanTarget,
+		tryRegister
+	};
+}
+
+//#endregion
+//#region src/discovery/walk.ts
+function createDependencyWalker(opts) {
+	const walkVisited = /* @__PURE__ */ new Set();
+	const depDirCache = /* @__PURE__ */ new Map();
+	function resolveDepDirCached(depName, fromDir) {
+		let byDepName = depDirCache.get(fromDir);
+		if (!byDepName) {
+			byDepName = /* @__PURE__ */ new Map();
+			depDirCache.set(fromDir, byDepName);
+		}
+		if (!byDepName.has(depName)) byDepName.set(depName, resolveDepDir(depName, fromDir));
+		return byDepName.get(depName) ?? null;
+	}
+	function walkDepsOf(pkgJson, fromDir, includeDevDeps = false) {
+		for (const depName of getDeps(pkgJson, includeDevDeps)) {
+			const depDir = resolveDepDirCached(depName, fromDir);
+			if (!depDir || walkVisited.has(depDir)) continue;
+			opts.tryRegister(depDir, depName);
+			walkDeps(depDir, depName);
+		}
+	}
+	function walkDeps(pkgDir, pkgName) {
+		if (walkVisited.has(pkgDir)) return;
+		walkVisited.add(pkgDir);
+		const pkgJson = opts.readPkgJson(pkgDir);
+		if (!pkgJson) {
+			opts.warnings.push(`Could not read package.json for ${pkgName} (skipping dependency walk)`);
+			return;
+		}
+		walkDepsOf(pkgJson, pkgDir);
+	}
+	function walkKnownPackages() {
+		for (const pkg of [...opts.packages]) walkDeps(pkg.packageRoot, pkg.name);
+	}
+	function walkProjectDeps() {
+		const projectPkg = readPkgJsonWithWarning(opts.projectRoot, "project");
+		if (!projectPkg) return;
+		walkDepsOf(projectPkg, opts.projectRoot, true);
+	}
+	function readPkgJsonWithWarning(dirPath, label) {
+		try {
+			return JSON.parse(readFileSync(join(dirPath, "package.json"), "utf8"));
+		} catch (err) {
+			if (err.code !== "ENOENT") opts.warnings.push(`Could not read ${label} package.json at ${dirPath}: ${err.message}`);
+			return null;
+		}
+	}
+	function walkWorkspacePackages() {
+		const workspacePatterns = readWorkspacePatterns(opts.projectRoot);
+		if (!workspacePatterns) return;
+		for (const wsDir of resolveWorkspacePackages(opts.projectRoot, workspacePatterns)) {
+			const wsNodeModules = join(wsDir, "node_modules");
+			if (existsSync(wsNodeModules)) for (const dirPath of listNodeModulesPackageDirs(wsNodeModules)) opts.tryRegister(dirPath, "unknown");
+			const wsPkg = readPkgJsonWithWarning(wsDir, "workspace");
+			if (wsPkg) walkDepsOf(wsPkg, wsDir);
+		}
+	}
+	return {
+		walkKnownPackages,
+		walkProjectDeps,
+		walkWorkspacePackages
+	};
+}
+
+//#endregion
 //#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.");
@@ -83,8 +211,8 @@ function discoverSkills(skillsDir, _baseName) {
 					type: typeof fm?.type === "string" ? fm.type : void 0,
 					framework: typeof fm?.framework === "string" ? fm.framework : void 0
 				});
-				walk(childDir);
 			}
+			walk(childDir);
 		}
 	}
 	walk(skillsDir);
@@ -169,8 +297,12 @@ function toVersionConflict(packageName, variants, chosen) {
 		variants
 	};
 }
-function scanForIntents(root) {
+function getScanScope(options) {
+	return options.scope ?? (options.includeGlobal ? "local-and-global" : "local");
+}
+function scanForIntents(root, options = {}) {
 	const projectRoot = root ?? process.cwd();
+	const scanScope = getScanScope(options);
 	const packageManager = detectPackageManager(projectRoot);
 	const nodeModulesDir = join(projectRoot, "node_modules");
 	const explicitGlobalNodeModules = process.env.INTENT_GLOBAL_NODE_MODULES?.trim() || null;
@@ -226,123 +358,50 @@ function scanForIntents(root) {
 			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 skills = discoverSkills(skillsDir, name);
-		if (dirPath.startsWith(projectRoot + sep) || dirPath.startsWith(projectRoot + "/")) {
-			const hasStableSymlink = name !== "" && existsSync(join(projectRoot, "node_modules", name));
-			for (const skill of skills) if (hasStableSymlink) skill.path = `node_modules/${name}/${toPosixPath(relative(dirPath, skill.path))}`;
-			else skill.path = toPosixPath(relative(projectRoot, skill.path));
-		}
-		const candidate = {
-			name,
-			version,
-			intent,
-			skills,
-			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);
+	const { scanTarget, tryRegister } = createPackageRegistrar({
+		comparePackageVersions,
+		deriveIntentConfig,
+		discoverSkills,
+		getPackageDepth,
+		packageIndexes,
+		packages,
+		projectRoot,
+		readPkgJson,
+		rememberVariant,
+		validateIntentField,
+		warnings
+	});
+	const { walkKnownPackages, walkProjectDeps, walkWorkspacePackages } = createDependencyWalker({
+		packages,
+		projectRoot,
+		readPkgJson,
+		tryRegister,
+		warnings
+	});
+	function scanLocalPackages() {
+		scanTarget(nodeModules.local);
+		walkWorkspacePackages();
 		walkKnownPackages();
 		walkProjectDeps();
 	}
+	function scanGlobalPackages() {
+		ensureGlobalNodeModules();
+		scanTarget(nodeModules.global, "global");
+	}
+	switch (scanScope) {
+		case "local":
+			scanLocalPackages();
+			break;
+		case "local-and-global":
+			scanLocalPackages();
+			scanGlobalPackages();
+			walkKnownPackages();
+			walkProjectDeps();
+			break;
+		case "global":
+			scanGlobalPackages();
+			break;
+	}
 	if (!nodeModules.local.exists && !nodeModules.global.exists) return {
 		packageManager,
 		packages,

package/dist/{setup-BzhEoOBi.mjs → setup-JJvjiGkM.mjs}

@@ -1,5 +1,5 @@
-import { n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-BuJMfudb.mjs";
-import { t as resolveProjectContext } from "./project-context-B7UXTA9F.mjs";
+import { n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-U35B5AO-.mjs";
+import { t as resolveProjectContext } from "./project-context-CKG-q4rD.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, join, relative } from "node:path";
 

package/dist/setup.d.mts

@@ -1,2 +1,2 @@
-import { a as runEditPackageJsonAll, c as findWorkspaceRoot, i as runEditPackageJson, l as readWorkspacePatterns, n as MonorepoResult, o as runSetupGithubActions, r as SetupGithubActionsResult, s as findPackagesWithSkills, t as EditPackageJsonResult, u as resolveWorkspacePackages } from "./setup-BA9RkENh.mjs";
+import { a as runEditPackageJsonAll, c as findWorkspaceRoot, i as runEditPackageJson, l as readWorkspacePatterns, n as MonorepoResult, o as runSetupGithubActions, r as SetupGithubActionsResult, s as findPackagesWithSkills, t as EditPackageJsonResult, u as resolveWorkspacePackages } from "./setup-DDoOLriA.mjs";
 export { EditPackageJsonResult, MonorepoResult, SetupGithubActionsResult, findPackagesWithSkills, findWorkspaceRoot, readWorkspacePatterns, resolveWorkspacePackages, runEditPackageJson, runEditPackageJsonAll, runSetupGithubActions };

package/dist/setup.mjs

@@ -1,6 +1,6 @@
 import "./utils-COlDcU72.mjs";
-import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-BuJMfudb.mjs";
-import "./project-context-B7UXTA9F.mjs";
-import { n as runEditPackageJsonAll, r as runSetupGithubActions, t as runEditPackageJson } from "./setup-BzhEoOBi.mjs";
+import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-U35B5AO-.mjs";
+import "./project-context-CKG-q4rD.mjs";
+import { n as runEditPackageJsonAll, r as runSetupGithubActions, t as runEditPackageJson } from "./setup-JJvjiGkM.mjs";
 
 export { findPackagesWithSkills, findWorkspaceRoot, readWorkspacePatterns, resolveWorkspacePackages, runEditPackageJson, runEditPackageJsonAll, runSetupGithubActions };

package/dist/skill-paths-8k9K9y26.mjs

@@ -0,0 +1,33 @@
+import { s as toPosixPath } from "./utils-COlDcU72.mjs";
+import { existsSync } from "node:fs";
+import { join, relative } from "node:path";
+
+//#region src/skill-paths.ts
+function isAbsolutePath(path) {
+	return path.startsWith("/") || path.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(path);
+}
+function getPathSegments(path) {
+	return path.replace(/\\/g, "/").split("/");
+}
+function isPackageManagerInternalSegment(segment) {
+	return segment === ".pnpm" || segment === ".bun" || segment === ".yarn";
+}
+function isStableLoadPath(path) {
+	const normalized = path.trim();
+	const segments = getPathSegments(normalized);
+	return normalized !== "" && !isAbsolutePath(normalized) && !segments.includes("..") && !segments.some(isPackageManagerInternalSegment);
+}
+function rewriteSkillLoadPaths({ packageName, packageRoot, projectRoot, skills }) {
+	const hasStableSymlink = packageName !== "" && existsSync(join(projectRoot, "node_modules", packageName));
+	for (const skill of skills) if (hasStableSymlink) skill.path = `node_modules/${packageName}/${toPosixPath(relative(packageRoot, skill.path))}`;
+	else skill.path = toPosixPath(relative(projectRoot, skill.path));
+}
+function formatRuntimeSkillLookupComment(target) {
+	return `Runtime lookup only: run \`npx @tanstack/intent@latest load ${target.packageName}#${target.skillName} --path\`, and load its reported path for this session. Do not copy the resolved path into this file.`;
+}
+function formatRuntimeSkillLookupHint(target) {
+	return `Lookup: ${formatRuntimeSkillLookupComment(target)}`;
+}
+
+//#endregion
+export { isStableLoadPath as n, rewriteSkillLoadPaths as r, formatRuntimeSkillLookupHint as t };

package/dist/skill-use-CXOnncWK.mjs

@@ -0,0 +1,42 @@
+//#region src/skill-use.ts
+var SkillUseParseError = class extends Error {
+	constructor(code, value) {
+		super(formatSkillUseParseErrorMessage(code, value));
+		this.name = "SkillUseParseError";
+		this.code = code;
+		this.value = value;
+	}
+};
+function isSkillUseParseError(error) {
+	return error instanceof SkillUseParseError;
+}
+function formatSkillUse(packageName, skillName) {
+	const pkg = packageName.trim();
+	const skill = skillName.trim();
+	if (pkg === "") throw new SkillUseParseError("empty-package", `${packageName}#${skillName}`);
+	if (skill === "") throw new SkillUseParseError("empty-skill", `${packageName}#${skillName}`);
+	return `${pkg}#${skill}`;
+}
+function parseSkillUse(value) {
+	const trimmed = value.trim();
+	const separatorIndex = trimmed.indexOf("#");
+	if (separatorIndex === -1) throw new SkillUseParseError("missing-separator", value);
+	const packageName = trimmed.slice(0, separatorIndex).trim();
+	const skillName = trimmed.slice(separatorIndex + 1).trim();
+	if (packageName === "") throw new SkillUseParseError("empty-package", value);
+	if (skillName === "") throw new SkillUseParseError("empty-skill", value);
+	return {
+		packageName,
+		skillName
+	};
+}
+function formatSkillUseParseErrorMessage(code, value) {
+	switch (code) {
+		case "missing-separator": return `Invalid skill use "${value}": expected <package>#<skill>.`;
+		case "empty-package": return `Invalid skill use "${value}": package is required.`;
+		case "empty-skill": return `Invalid skill use "${value}": skill is required.`;
+	}
+}
+
+//#endregion
+export { parseSkillUse as i, formatSkillUse as n, isSkillUseParseError as r, SkillUseParseError as t };

package/dist/{staleness-BtmJtMpz.mjs → staleness-DorwfGrf.mjs}

@@ -12,6 +12,14 @@ function classifyVersionDrift(oldVer, newVer) {
 	if ((newParts[2] ?? 0) > (oldParts[2] ?? 0)) return "patch";
 	return null;
 }
+function readLocalVersion(packageDir) {
+	try {
+		const pkgJson = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
+		return typeof pkgJson.version === "string" ? pkgJson.version : null;
+	} catch {
+		return null;
+	}
+}
 async function fetchNpmVersion(packageName) {
 	try {
 		const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`);
@@ -22,6 +30,9 @@ async function fetchNpmVersion(packageName) {
 		return null;
 	}
 }
+async function fetchCurrentVersion(packageDir, packageName) {
+	return readLocalVersion(packageDir) ?? await fetchNpmVersion(packageName);
+}
 function isStringRecord(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
@@ -65,7 +76,7 @@ async function checkStaleness(packageDir, packageName) {
 		};
 	});
 	const skillVersion = skillMetas.find((s) => s.libraryVersion)?.libraryVersion ?? null;
-	const currentVersion = await fetchNpmVersion(library);
+	const currentVersion = await fetchCurrentVersion(packageDir, library);
 	const versionDrift = skillVersion && currentVersion ? classifyVersionDrift(skillVersion, currentVersion) : null;
 	const syncState = readSyncState(packageDir);
 	return {

package/dist/staleness-NF-lxfXf.mjs

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

package/dist/{types-BTQ9efv-.d.mts → types-CsySN6Vw.d.mts}

@@ -15,6 +15,11 @@ interface ScanResult {
     global: NodeModulesScanTarget;
   };
 }
+type ScanScope = 'local' | 'local-and-global' | 'global';
+interface ScanOptions {
+  includeGlobal?: boolean;
+  scope?: ScanScope;
+}
 interface NodeModulesScanTarget {
   path: string | null;
   detected: boolean;
@@ -28,6 +33,7 @@ interface IntentPackage {
   intent: IntentConfig;
   skills: Array<SkillEntry>;
   packageRoot: string;
+  source: 'local' | 'global';
 }
 interface InstalledVariant {
   version: string;
@@ -90,4 +96,4 @@ interface IntentProjectConfig {
   };
 }
 //#endregion
-export { IntentProjectConfig as a, ScanResult as c, StalenessReport as d, IntentPackage as i, SkillEntry as l, FeedbackPayload as n, MetaFeedbackPayload as o, IntentConfig as r, MetaSkillName as s, AgentName as t, SkillStaleness as u };
+export { IntentProjectConfig as a, ScanOptions as c, SkillStaleness as d, StalenessReport as f, IntentPackage as i, ScanResult as l, FeedbackPayload as n, MetaFeedbackPayload as o, VersionConflict as p, IntentConfig as r, MetaSkillName as s, AgentName as t, SkillEntry as u };

package/dist/{workspace-patterns-Boa5mAbf.mjs → workspace-patterns-DbnA0peB.mjs}

@@ -1,4 +1,4 @@
 import "./utils-COlDcU72.mjs";
-import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-BuJMfudb.mjs";
+import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-U35B5AO-.mjs";
 
 export { findPackagesWithSkills, findWorkspaceRoot };

package/dist/{workspace-patterns-BuJMfudb.mjs → workspace-patterns-U35B5AO-.mjs}

@@ -17,21 +17,90 @@ function parseWorkspacePatterns(value) {
 function hasPackageJson(dir) {
 	return existsSync(join(dir, "package.json"));
 }
+function stripJsonCommentsAndTrailingCommas(source) {
+	let result = "";
+	let inString = false;
+	let escaped = false;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (inString) {
+			result += char;
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") {
+			inString = true;
+			result += char;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			while (index < source.length && source[index] !== "\n") index += 1;
+			if (index < source.length) result += source[index];
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			const commentStart = index;
+			index += 2;
+			while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) index += 1;
+			if (index >= source.length) throw new SyntaxError(`Unterminated block comment starting at position ${commentStart}`);
+			index += 1;
+			continue;
+		}
+		if (char === ",") {
+			let lookahead = index + 1;
+			while (lookahead < source.length) {
+				const la = source[lookahead];
+				if (/\s/.test(la)) lookahead += 1;
+				else if (la === "/" && source[lookahead + 1] === "/") {
+					lookahead += 2;
+					while (lookahead < source.length && source[lookahead] !== "\n") lookahead += 1;
+				} else if (la === "/" && source[lookahead + 1] === "*") {
+					lookahead += 2;
+					while (lookahead < source.length && !(source[lookahead] === "*" && source[lookahead + 1] === "/")) lookahead += 1;
+					lookahead += 2;
+				} else break;
+			}
+			if (source[lookahead] === "}" || source[lookahead] === "]") continue;
+		}
+		result += char;
+	}
+	return result;
+}
+function readJsonFile(path, jsonc = false) {
+	const source = readFileSync(path, "utf8");
+	return JSON.parse(jsonc ? stripJsonCommentsAndTrailingCommas(source) : source);
+}
 function readWorkspacePatterns(root) {
 	const pnpmWs = join(root, "pnpm-workspace.yaml");
 	if (existsSync(pnpmWs)) try {
 		const patterns = parseWorkspacePatterns(parse(readFileSync(pnpmWs, "utf8")).packages);
 		if (patterns) return patterns;
 	} catch (err) {
-		console.error(`Warning: failed to parse ${pnpmWs}: ${err instanceof Error ? err.message : err}`);
+		const verb = err instanceof SyntaxError ? "parse" : "read";
+		console.error(`Warning: failed to ${verb} ${pnpmWs}: ${err instanceof Error ? err.message : err}`);
 	}
 	const pkgPath = join(root, "package.json");
 	if (existsSync(pkgPath)) try {
-		const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-		const patterns = parseWorkspacePatterns(pkg.workspaces) ?? parseWorkspacePatterns(pkg.workspaces?.packages);
+		const workspaces = readJsonFile(pkgPath).workspaces;
+		const patterns = parseWorkspacePatterns(workspaces) ?? parseWorkspacePatterns(workspaces?.packages);
 		if (patterns) return patterns;
 	} catch (err) {
-		console.error(`Warning: failed to parse ${pkgPath}: ${err instanceof Error ? err.message : err}`);
+		const verb = err instanceof SyntaxError ? "parse" : "read";
+		console.error(`Warning: failed to ${verb} ${pkgPath}: ${err instanceof Error ? err.message : err}`);
+	}
+	for (const denoConfigName of ["deno.json", "deno.jsonc"]) {
+		const denoConfigPath = join(root, denoConfigName);
+		if (!existsSync(denoConfigPath)) continue;
+		try {
+			const patterns = parseWorkspacePatterns(readJsonFile(denoConfigPath, true).workspace);
+			if (patterns) return patterns;
+		} catch (err) {
+			const verb = err instanceof SyntaxError ? "parse" : "read";
+			console.error(`Warning: failed to ${verb} ${denoConfigPath}: ${err instanceof Error ? err.message : err}`);
+		}
 	}
 	return null;
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@tanstack/intent",
-  "version": "0.0.27",
+  "version": "0.0.32",
   "description": "Ship compositional knowledge for AI coding agents alongside your npm packages",
   "license": "MIT",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/tanstack/intent"
+    "url": "https://github.com/TanStack/intent"
   },
   "exports": {
     ".": {
@@ -36,11 +36,10 @@
     "verdaccio": "^6.3.2"
   },
   "scripts": {
-    "prepack": "npm run build",
     "build": "tsdown src/index.ts src/cli.ts src/setup.ts src/intent-library.ts src/library-scanner.ts --format esm --dts",
     "test:smoke": "pnpm run build && node dist/cli.mjs --help > /dev/null",
     "test:lib": "vitest run --exclude 'tests/integration/**'",
     "test:integration": "vitest run tests/integration/",
     "test:types": "tsc --noEmit"
   }
-}
+}

package/dist/display-DdmZXLZm.mjs

@@ -1,3 +0,0 @@
-import { n as printSkillTree, r as printTable, t as computeSkillNameWidth } from "./display-hdsqb4w-.mjs";
-
-export { computeSkillNameWidth, printSkillTree, printTable };