@tanstack/intent 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,61 @@
+import { a as IntentProjectConfig, c as ScanResult, d as StalenessReport, i as IntentPackage, l as SkillEntry, n as FeedbackPayload, o as MetaFeedbackPayload, r as IntentConfig, s as MetaSkillName, t as AgentName, u as SkillStaleness } from "./types-kbQfN_is.mjs";
+import { n as runSetup } from "./setup-N5dttGp_.mjs";
+
+//#region src/scanner.d.ts
+declare function scanForIntents(root?: string): Promise<ScanResult>;
+//#endregion
+//#region src/staleness.d.ts
+declare function checkStaleness(packageDir: string, packageName?: string): Promise<StalenessReport>;
+//#endregion
+//#region src/feedback.d.ts
+declare function containsSecrets(text: string): boolean;
+declare function hasGhCli(): boolean;
+declare function resolveFrequency(root: string): string;
+declare function validatePayload(payload: unknown): {
+  valid: boolean;
+  errors: string[];
+};
+declare function validateMetaPayload(payload: unknown): {
+  valid: boolean;
+  errors: string[];
+};
+declare function metaToMarkdown(payload: MetaFeedbackPayload): string;
+declare function toMarkdown(payload: FeedbackPayload): string;
+interface SubmitResult {
+  method: 'gh' | 'file' | 'stdout';
+  detail: string;
+}
+declare function submitFeedback(payload: FeedbackPayload, repo: string, opts: {
+  ghAvailable: boolean;
+  outputPath?: string;
+}): SubmitResult;
+declare function submitMetaFeedback(payload: MetaFeedbackPayload, opts: {
+  ghAvailable: boolean;
+  outputPath?: string;
+}): SubmitResult;
+//#endregion
+//#region src/init.d.ts
+declare function detectAgentConfigs(root: string): string[];
+declare function hasIntentBlock(filePath: string): boolean;
+declare function injectIntentBlock(filePath: string): boolean;
+declare function writeProjectConfig(root: string): string;
+declare function readProjectConfig(root: string): IntentProjectConfig | null;
+interface InitResult {
+  injected: string[];
+  skipped: string[];
+  created: string[];
+  configPath: string;
+}
+declare function runInit(root: string): InitResult;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Recursively find all SKILL.md files under a directory.
+ */
+declare function findSkillFiles(dir: string): string[];
+/**
+ * Parse YAML frontmatter from a file. Returns null if no frontmatter or on error.
+ */
+declare function parseFrontmatter(filePath: string): Record<string, unknown> | null;
+//#endregion
+export { type AgentName, type FeedbackPayload, type IntentConfig, type IntentPackage, type IntentProjectConfig, type MetaFeedbackPayload, type MetaSkillName, type ScanResult, type SkillEntry, type SkillStaleness, type StalenessReport, checkStaleness, containsSecrets, detectAgentConfigs, findSkillFiles, hasGhCli, hasIntentBlock, injectIntentBlock, metaToMarkdown, parseFrontmatter, readProjectConfig, resolveFrequency, runInit, runSetup, scanForIntents, submitFeedback, submitMetaFeedback, toMarkdown, validateMetaPayload, validatePayload, writeProjectConfig };

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import { n as parseFrontmatter, t as findSkillFiles } from "./utils-DjkEPBxu.mjs";
+import { t as scanForIntents } from "./scanner-CpsJAHXT.mjs";
+import { t as checkStaleness } from "./staleness-CnomT9Hm.mjs";
+import { c as toMarkdown, i as resolveFrequency, l as validateMetaPayload, n as hasGhCli, o as submitFeedback, r as metaToMarkdown, s as submitMetaFeedback, t as containsSecrets, u as validatePayload } from "./feedback-DKreHfB1.mjs";
+import { a as runInit, i as readProjectConfig, n as hasIntentBlock, o as writeProjectConfig, r as injectIntentBlock, t as detectAgentConfigs } from "./init-DNxmjQfU.mjs";
+import { t as runSetup } from "./setup-CNGz26qL.mjs";
+
+export { checkStaleness, containsSecrets, detectAgentConfigs, findSkillFiles, hasGhCli, hasIntentBlock, injectIntentBlock, metaToMarkdown, parseFrontmatter, readProjectConfig, resolveFrequency, runInit, runSetup, scanForIntents, submitFeedback, submitMetaFeedback, toMarkdown, validateMetaPayload, validatePayload, writeProjectConfig };

package/dist/init-DEzzXm9j.mjs

@@ -0,0 +1,3 @@
+import { a as runInit, i as readProjectConfig, n as hasIntentBlock, o as writeProjectConfig, r as injectIntentBlock, t as detectAgentConfigs } from "./init-DNxmjQfU.mjs";
+
+export { detectAgentConfigs, runInit };

package/dist/init-DNxmjQfU.mjs

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/init.ts
+const AGENT_CONFIG_FILES = [
+	"AGENTS.md",
+	"CLAUDE.md",
+	".cursorrules",
+	".github/copilot-instructions.md"
+];
+const INTENT_BLOCK_MARKER = "## Intent Skills";
+const INTENT_BLOCK = `## Intent Skills
+
+This project uses TanStack Intent. Run \`npx intent list\` to discover
+available AI coding skills. Before working with a library that has skills,
+read the relevant SKILL.md file at the path shown in the list output.
+`;
+const DEFAULT_CONFIG = { feedback: { frequency: "every-5" } };
+function detectAgentConfigs(root) {
+	return AGENT_CONFIG_FILES.map((f) => join(root, f)).filter((f) => existsSync(f));
+}
+function hasIntentBlock(filePath) {
+	try {
+		return readFileSync(filePath, "utf8").includes(INTENT_BLOCK_MARKER);
+	} catch {
+		return false;
+	}
+}
+function injectIntentBlock(filePath) {
+	if (hasIntentBlock(filePath)) return false;
+	let content;
+	try {
+		content = readFileSync(filePath, "utf8");
+	} catch {
+		content = "";
+	}
+	const separator = content.length > 0 && !content.endsWith("\n\n") ? "\n\n" : "";
+	writeFileSync(filePath, content + separator + INTENT_BLOCK);
+	return true;
+}
+function writeProjectConfig(root) {
+	const configPath = join(root, "intent.config.json");
+	if (!existsSync(configPath)) writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
+	return configPath;
+}
+function readProjectConfig(root) {
+	const configPath = join(root, "intent.config.json");
+	try {
+		return JSON.parse(readFileSync(configPath, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function runInit(root) {
+	const detected = detectAgentConfigs(root);
+	const injected = [];
+	const skipped = [];
+	const created = [];
+	for (const filePath of detected) if (injectIntentBlock(filePath)) injected.push(filePath);
+	else skipped.push(filePath);
+	return {
+		injected,
+		skipped,
+		created,
+		configPath: writeProjectConfig(root)
+	};
+}
+
+//#endregion
+export { runInit as a, readProjectConfig as i, hasIntentBlock as n, writeProjectConfig as o, injectIntentBlock as r, detectAgentConfigs as t };

package/dist/intent-library.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/intent-library.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import "./utils-DjkEPBxu.mjs";
+import { t as scanLibrary } from "./library-scanner-BrznE00j.mjs";
+import { spawnSync } from "node:child_process";
+import { release } from "node:os";
+
+//#region src/intent-library.ts
+async function cmdList() {
+	let result;
+	try {
+		result = await scanLibrary(process.argv[1]);
+	} catch (err) {
+		console.error(err.message);
+		process.exit(1);
+	}
+	if (result.packages.length === 0) {
+		console.log("No intent-enabled packages found.");
+		if (result.warnings.length > 0) {
+			console.log("\nWarnings:");
+			for (const w of result.warnings) console.log(`  ⚠ ${w}`);
+		}
+		return;
+	}
+	for (const pkg of result.packages) {
+		const header = pkg.description ? `${pkg.name} v${pkg.version} — ${pkg.description}` : `${pkg.name} v${pkg.version}`;
+		console.log(header);
+		for (const skill of pkg.skills) {
+			const name = skill.name.padEnd(28);
+			const desc = (skill.description || "").padEnd(52);
+			console.log(`  ${name}${desc}${skill.path}`);
+		}
+		console.log();
+	}
+	if (result.warnings.length > 0) {
+		console.log("Warnings:");
+		for (const w of result.warnings) console.log(`  ⚠ ${w}`);
+	}
+}
+function cmdInstall() {
+	function tryCopyToClipboard(text) {
+		const platform = process.platform;
+		const isWsl = platform === "linux" && (Boolean(process.env.WSL_DISTRO_NAME) || Boolean(process.env.WSL_INTEROP) || release().toLowerCase().includes("microsoft"));
+		const tryCommand = (command$1, args = []) => {
+			return spawnSync(command$1, args, { input: text }).status === 0;
+		};
+		if (platform === "darwin") return tryCommand("pbcopy");
+		if (platform === "win32") return tryCommand("clip");
+		if (isWsl) return tryCommand("clip.exe");
+		return tryCommand("wl-copy") || tryCommand("xclip", ["-selection", "clipboard"]) || tryCommand("xsel", ["--clipboard", "--input"]);
+	}
+	const prompt = `You are an AI assistant helping a developer set up skill-to-task mappings for their project.
+
+Follow these steps in order:
+
+1. CHECK FOR EXISTING MAPPINGS
+   Search the project's agent config files (CLAUDE.md, AGENTS.md, .cursorrules,
+   .github/copilot-instructions.md) for a block delimited by:
+     <!-- intent-skills:start -->
+     <!-- intent-skills:end -->
+   - If found: show the user the current mappings and ask "What would you like to update?"
+     Then skip to step 4 with their requested changes.
+   - If not found: continue to step 2.
+
+2. DISCOVER AVAILABLE SKILLS
+   Run: intent list
+   This outputs each skill's name, description, and full path — grouped by package.
+
+3. SCAN THE REPOSITORY
+   Build a picture of the project's structure and patterns:
+   - Read package.json for library dependencies
+   - Survey the directory layout (src/, app/, routes/, components/, api/, etc.)
+   - Note recurring patterns (routing, data fetching, auth, UI components, etc.)
+
+   Based on this, propose 3–5 skill-to-task mappings. For each one explain:
+   - The task or code area (in plain language the user would recognise)
+   - Which skill applies and why
+
+   Then ask: "What other tasks do you commonly use AI coding agents for?
+   I'll create mappings for those too."
+
+4. WRITE THE MAPPINGS BLOCK
+   Once you have the full set of mappings, write or update the agent config file
+   (prefer CLAUDE.md; create it if none exists) with this exact block:
+
+<!-- intent-skills:start -->
+# Skill mappings — when working in these areas, load the linked skill file into context.
+skills:
+  - task: "describe the task or code area here"
+    load: "node_modules/package-name/skills/skill-name/SKILL.md"
+<!-- intent-skills:end -->
+
+   Rules:
+   - Use the user's own words for task descriptions
+   - Include the exact path from \`intent list\` output so agents can load it directly
+   - Keep entries concise — this block is read on every agent task
+   - Preserve all content outside the block tags unchanged`;
+	console.log("🚀 Intent Install");
+	console.log("✨ Copy the prompt below into your AI agent:\n");
+	console.log(prompt);
+	if (tryCopyToClipboard(prompt)) console.log("\n✅ Copied prompt to clipboard");
+	else console.log("\n⚠ Tip: Manually copy the prompt above into your agent");
+}
+const USAGE = `TanStack Intent
+
+Usage:
+  intent list        List all available skills from this library and its dependencies
+  intent install     Set up skill-to-task mappings in your agent config`;
+const command = process.argv[2];
+switch (command) {
+	case "list":
+	case void 0:
+		await cmdList();
+		break;
+	case "install":
+		cmdInstall();
+		break;
+	default:
+		console.log(USAGE);
+		process.exit(command ? 1 : 0);
+}
+
+//#endregion
+export {  };

package/dist/library-scanner-BrznE00j.mjs

@@ -0,0 +1,111 @@
+import { n as parseFrontmatter } from "./utils-DjkEPBxu.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+
+//#region src/library-scanner.ts
+function readPkgJson(dir) {
+	try {
+		return JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+function findHomeDir(scriptPath) {
+	let dir = dirname(scriptPath);
+	while (true) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+function hasIntentBin(pkg) {
+	const bin = pkg.bin;
+	if (!bin || typeof bin !== "object") return false;
+	return "intent" in bin;
+}
+function getDeps(pkg) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const field of ["dependencies", "peerDependencies"]) {
+		const d = pkg[field];
+		if (d && typeof d === "object") for (const name of Object.keys(d)) seen.add(name);
+	}
+	return [...seen];
+}
+function discoverSkills(skillsDir) {
+	const skills = [];
+	function walk(dir) {
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} 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("/");
+				skills.push({
+					name: typeof fm?.name === "string" ? fm.name : relName,
+					path: skillFile,
+					description: typeof fm?.description === "string" ? fm.description.replace(/\s+/g, " ").trim() : "",
+					type: typeof fm?.type === "string" ? fm.type : void 0,
+					framework: typeof fm?.framework === "string" ? fm.framework : void 0
+				});
+				walk(childDir);
+			}
+		}
+	}
+	walk(skillsDir);
+	return skills;
+}
+async function scanLibrary(scriptPath, projectRoot) {
+	const nodeModulesDir = join(projectRoot ?? process.cwd(), "node_modules");
+	const packages = [];
+	const warnings = [];
+	const visited = /* @__PURE__ */ new Set();
+	const homeDir = findHomeDir(scriptPath);
+	if (!homeDir) return {
+		packages,
+		warnings: ["Could not determine home package directory"]
+	};
+	const homePkg = readPkgJson(homeDir);
+	if (!homePkg) return {
+		packages,
+		warnings: ["Could not read home package.json"]
+	};
+	const homeName = typeof homePkg.name === "string" ? homePkg.name : "";
+	function processPackage(name, dir) {
+		if (visited.has(name)) return;
+		visited.add(name);
+		const pkg = readPkgJson(dir);
+		if (!pkg) {
+			warnings.push(`Could not read package.json for ${name}`);
+			return;
+		}
+		const skillsDir = join(dir, "skills");
+		packages.push({
+			name,
+			version: typeof pkg.version === "string" ? pkg.version : "0.0.0",
+			description: typeof pkg.description === "string" ? pkg.description : "",
+			skills: existsSync(skillsDir) ? discoverSkills(skillsDir) : []
+		});
+		for (const depName of getDeps(pkg)) {
+			const depDir = join(nodeModulesDir, depName);
+			if (!existsSync(depDir)) continue;
+			const depPkg = readPkgJson(depDir);
+			if (depPkg && hasIntentBin(depPkg)) processPackage(depName, depDir);
+		}
+	}
+	processPackage(homeName, homeDir);
+	return {
+		packages,
+		warnings
+	};
+}
+
+//#endregion
+export { scanLibrary as t };

package/dist/library-scanner.d.mts

@@ -0,0 +1,16 @@
+import { l as SkillEntry } from "./types-kbQfN_is.mjs";
+
+//#region src/library-scanner.d.ts
+interface LibraryPackage {
+  name: string;
+  version: string;
+  description: string;
+  skills: SkillEntry[];
+}
+interface LibraryScanResult {
+  packages: LibraryPackage[];
+  warnings: string[];
+}
+declare function scanLibrary(scriptPath: string, projectRoot?: string): Promise<LibraryScanResult>;
+//#endregion
+export { LibraryPackage, LibraryScanResult, scanLibrary };

package/dist/library-scanner.mjs

@@ -0,0 +1,4 @@
+import "./utils-DjkEPBxu.mjs";
+import { t as scanLibrary } from "./library-scanner-BrznE00j.mjs";
+
+export { scanLibrary };

package/dist/scanner-BuWPDJ4P.mjs

@@ -0,0 +1,4 @@
+import "./utils-DjkEPBxu.mjs";
+import { t as scanForIntents } from "./scanner-CpsJAHXT.mjs";
+
+export { scanForIntents };

package/dist/scanner-CpsJAHXT.mjs

@@ -0,0 +1,147 @@
+import { n as parseFrontmatter } from "./utils-DjkEPBxu.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.");
+	if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun";
+	if (existsSync(join(root, "yarn.lock"))) return "yarn";
+	if (existsSync(join(root, "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
+	};
+}
+function discoverSkills(skillsDir, baseName) {
+	const skills = [];
+	function walk(dir) {
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} 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;
+}
+async function scanForIntents(root) {
+	const projectRoot = root ?? process.cwd();
+	const packageManager = detectPackageManager(projectRoot);
+	const nodeModulesDir = join(projectRoot, "node_modules");
+	const packages = [];
+	const warnings = [];
+	if (!existsSync(nodeModulesDir)) return {
+		packageManager,
+		packages,
+		warnings
+	};
+	const packageDirs = [];
+	let topEntries;
+	try {
+		topEntries = readdirSync(nodeModulesDir, { withFileTypes: true });
+	} catch {
+		return {
+			packageManager,
+			packages,
+			warnings
+		};
+	}
+	for (const entry of topEntries) {
+		if (!entry.isDirectory()) continue;
+		const dirPath = join(nodeModulesDir, entry.name);
+		if (entry.name.startsWith("@")) {
+			let scopedEntries;
+			try {
+				scopedEntries = readdirSync(dirPath, { withFileTypes: true });
+			} catch {
+				continue;
+			}
+			for (const scoped of scopedEntries) {
+				if (!scoped.isDirectory()) continue;
+				packageDirs.push({ dirPath: join(dirPath, scoped.name) });
+			}
+		} else if (!entry.name.startsWith(".")) packageDirs.push({ dirPath });
+	}
+	for (const { dirPath } of packageDirs) {
+		const skillsDir = join(dirPath, "skills");
+		if (!existsSync(skillsDir)) continue;
+		const pkgJsonPath = join(dirPath, "package.json");
+		let pkgJson;
+		try {
+			pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+		} catch {
+			warnings.push(`Could not read package.json for ${dirPath}`);
+			continue;
+		}
+		const pkgName = typeof pkgJson.name === "string" ? pkgJson.name : "unknown";
+		const pkgVersion = typeof pkgJson.version === "string" ? pkgJson.version : "0.0.0";
+		const intent = validateIntentField(pkgName, pkgJson.intent);
+		if (!intent) {
+			warnings.push(`${pkgName} has a skills/ directory but missing or invalid "intent" field in package.json`);
+			continue;
+		}
+		const skills = discoverSkills(skillsDir, pkgName);
+		packages.push({
+			name: pkgName,
+			version: pkgVersion,
+			intent,
+			skills
+		});
+	}
+	return {
+		packageManager,
+		packages: topoSort(packages),
+		warnings
+	};
+}
+
+//#endregion
+export { scanForIntents as t };

package/dist/setup-CNGz26qL.mjs

@@ -0,0 +1,116 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/setup.ts
+function detectVars(root) {
+	const pkgPath = join(root, "package.json");
+	let pkgJson = {};
+	try {
+		pkgJson = JSON.parse(readFileSync(pkgPath, "utf8"));
+	} catch {}
+	const name = typeof pkgJson.name === "string" ? pkgJson.name : "unknown";
+	const intent = pkgJson.intent;
+	const repo = typeof intent?.repo === "string" ? intent.repo : name.replace(/^@/, "").replace(/\//, "/");
+	const docs = typeof intent?.docs === "string" ? intent.docs : "docs/";
+	let srcPath = `packages/${name.replace(/^@[^/]+\//, "")}/src/**`;
+	if (existsSync(join(root, "src"))) srcPath = "src/**";
+	return {
+		PACKAGE_NAME: name,
+		REPO: repo,
+		DOCS_PATH: docs.endsWith("**") ? docs : docs.replace(/\/$/, "") + "/**",
+		SRC_PATH: srcPath
+	};
+}
+function applyVars(content, vars) {
+	return content.replace(/\{\{PACKAGE_NAME\}\}/g, vars.PACKAGE_NAME).replace(/\{\{REPO\}\}/g, vars.REPO).replace(/\{\{DOCS_PATH\}\}/g, vars.DOCS_PATH).replace(/\{\{SRC_PATH\}\}/g, vars.SRC_PATH);
+}
+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;
+		}
+		writeFileSync(destPath, applyVars(readFileSync(srcPath, "utf8"), vars));
+		copied.push(destPath);
+	}
+	return {
+		copied,
+		skipped
+	};
+}
+const SHIM_CONTENT = `#!/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.js" }
+await import('@tanstack/intent/intent-library')
+`;
+function generateShim(root, result) {
+	const shimPath = join(root, "bin", "intent.js");
+	if (existsSync(shimPath)) {
+		result.skipped.push(shimPath);
+		return;
+	}
+	mkdirSync(join(root, "bin"), { recursive: true });
+	writeFileSync(shimPath, SHIM_CONTENT);
+	result.shim = shimPath;
+}
+function runSetup(root, metaDir, args) {
+	const doAll = args.includes("--all");
+	const doWorkflows = doAll || args.includes("--workflows");
+	const doOz = doAll || args.includes("--oz");
+	const doShim = doAll || args.includes("--shim");
+	const defaultAll = !doWorkflows && !doOz && !doShim;
+	const installWorkflows = doWorkflows || defaultAll;
+	const installOz = doOz || defaultAll;
+	const installShim = doShim || defaultAll;
+	const vars = detectVars(root);
+	const result = {
+		workflows: [],
+		oz: [],
+		skipped: [],
+		shim: null
+	};
+	const templatesDir = join(metaDir, "templates");
+	if (installWorkflows) {
+		const { copied, skipped } = copyTemplates(join(templatesDir, "workflows"), join(root, ".github", "workflows"), vars);
+		result.workflows = copied;
+		result.skipped.push(...skipped);
+	}
+	if (installOz) {
+		const { copied, skipped } = copyTemplates(join(templatesDir, "oz"), join(root, ".intent", "oz"), vars);
+		result.oz = copied;
+		result.skipped.push(...skipped);
+	}
+	if (installShim) generateShim(root, result);
+	for (const f of result.workflows) console.log(`✓ Copied workflow: ${f}`);
+	for (const f of result.oz) console.log(`✓ Copied Oz prompt: ${f}`);
+	for (const f of result.skipped) console.log(`  Already exists: ${f}`);
+	if (result.shim) {
+		console.log(`✓ Generated intent shim: ${result.shim}`);
+		console.log(`\n  Add to your package.json:`);
+		console.log(`    "bin": { "intent": "./bin/intent.js" }`);
+		console.log(`\n  Add bin/intent.js to your package.json "files" array.`);
+	}
+	if (result.workflows.length === 0 && result.oz.length === 0 && result.shim === null && result.skipped.length === 0) console.log("No templates directory found. Is @tanstack/intent installed?");
+	else if (result.workflows.length > 0 || result.oz.length > 0) {
+		console.log(`\nTemplate variables applied:`);
+		console.log(`  Package:  ${vars.PACKAGE_NAME}`);
+		console.log(`  Repo:     ${vars.REPO}`);
+		console.log(`  Docs:     ${vars.DOCS_PATH}`);
+		console.log(`  Src:      ${vars.SRC_PATH}`);
+	}
+	return result;
+}
+
+//#endregion
+export { runSetup as t };

package/dist/setup-N5dttGp_.d.mts

@@ -0,0 +1,10 @@
+//#region src/setup.d.ts
+interface SetupResult {
+  workflows: string[];
+  oz: string[];
+  skipped: string[];
+  shim: string | null;
+}
+declare function runSetup(root: string, metaDir: string, args: string[]): SetupResult;
+//#endregion
+export { runSetup as n, SetupResult as t };