@tanstack/intent 0.0.1

package/README.md

@@ -0,0 +1,66 @@
+# @tanstack/intent
+
+Ship compositional knowledge for AI coding agents alongside your npm packages.
+
+Skills are npm packages of knowledge — encoding how tools work together, what patterns apply for which goals, and what to avoid. Skills travel with the tool via `npm update`, not the model's training cutoff.
+
+`@tanstack/intent` is the toolkit for generating, discovering, and maintaining skills for your library.
+
+## Install
+
+```bash
+pnpm add -D @tanstack/intent
+```
+
+## Quick Start
+
+### For library consumers
+
+Set up intent discovery in your project's agent config files (CLAUDE.md, .cursorrules, etc.):
+
+```bash
+npx intent init
+```
+
+List available skills from installed packages:
+
+```bash
+npx intent list
+```
+
+### For library maintainers
+
+Generate skills for your library using the guided scaffold workflow:
+
+```bash
+npx intent scaffold
+```
+
+Validate your skill files:
+
+```bash
+npx intent validate
+```
+
+Copy CI and Oz workflow templates into your repo:
+
+```bash
+npx intent setup
+```
+
+## CLI Commands
+
+| Command                  | Description                                      |
+| ------------------------ | ------------------------------------------------ |
+| `intent init`            | Inject intent discovery into agent config files  |
+| `intent list [--json]`   | Discover intent-enabled packages                 |
+| `intent meta`            | List meta-skills for library maintainers         |
+| `intent scaffold`        | Print the guided skill generation prompt         |
+| `intent validate [dir]`  | Validate SKILL.md files                          |
+| `intent setup`           | Copy CI/Oz workflow templates                    |
+| `intent stale [--json]`  | Check skills for version drift                   |
+| `intent feedback`        | Submit skill feedback                            |
+
+## License
+
+[MIT](./LICENSE)

package/dist/cli.d.mts

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

package/dist/cli.mjs

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+import { n as parseFrontmatter, t as findSkillFiles } from "./utils-DjkEPBxu.mjs";
+import { t as scanForIntents } from "./scanner-CpsJAHXT.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { parse } from "yaml";
+import { spawnSync } from "node:child_process";
+import { release } from "node:os";
+import { fileURLToPath } from "node:url";
+
+//#region src/cli.ts
+function getMetaDir() {
+	return join(dirname(fileURLToPath(import.meta.url)), "..", "meta");
+}
+async function cmdList(args) {
+	const jsonOutput = args.includes("--json");
+	let result;
+	try {
+		result = await scanForIntents();
+	} catch (err) {
+		console.error(err.message);
+		process.exit(1);
+	}
+	if (jsonOutput) {
+		console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+	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;
+	}
+	console.log(`Intent-enabled packages (${result.packages.length} found):\n`);
+	for (const pkg of result.packages) {
+		const reqStr = pkg.intent.requires?.length ? `  (requires: ${pkg.intent.requires.join(", ")})` : "";
+		console.log(`${pkg.name} v${pkg.version}${reqStr}`);
+		for (const skill of pkg.skills) {
+			const desc = skill.description ? `  ${skill.description}` : "";
+			console.log(`  ${skill.name.padEnd(32)}${desc}`);
+		}
+		console.log();
+	}
+	if (result.warnings.length > 0) {
+		console.log(`Warnings:`);
+		for (const w of result.warnings) console.log(`  ⚠ ${w}`);
+	}
+}
+function cmdMeta() {
+	const metaDir = getMetaDir();
+	if (!existsSync(metaDir)) {
+		console.error("Meta-skills directory not found.");
+		process.exit(1);
+	}
+	const entries = readdirSync(metaDir, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => existsSync(join(metaDir, e.name, "SKILL.md")));
+	if (entries.length === 0) {
+		console.log("No meta-skills found.");
+		return;
+	}
+	console.log("Meta-skills (for library maintainers):\n");
+	for (const entry of entries) {
+		const fm = parseFrontmatter(join(metaDir, entry.name, "SKILL.md"));
+		let description = "";
+		if (typeof fm?.description === "string") description = fm.description.replace(/\s+/g, " ").trim();
+		const shortDesc = description.length > 60 ? description.slice(0, 57) + "..." : description;
+		console.log(`  ${entry.name.padEnd(28)} ${shortDesc}`);
+	}
+	console.log(`\nUsage: load the SKILL.md into your AI agent conversation.`);
+	console.log(`Path: node_modules/@tanstack/intent/meta/<name>/SKILL.md`);
+}
+function cmdValidate(args) {
+	const targetDir = args[0] ?? "skills";
+	const skillsDir = join(process.cwd(), targetDir);
+	if (!existsSync(skillsDir)) {
+		console.error(`Skills directory not found: ${skillsDir}`);
+		process.exit(1);
+	}
+	const errors = [];
+	const skillFiles = findSkillFiles(skillsDir);
+	if (skillFiles.length === 0) {
+		console.error("No SKILL.md files found");
+		process.exit(1);
+	}
+	for (const filePath of skillFiles) {
+		const rel = relative(process.cwd(), filePath);
+		const content = readFileSync(filePath, "utf8");
+		const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)/);
+		if (!match) {
+			errors.push({
+				file: rel,
+				message: "Missing or invalid frontmatter"
+			});
+			continue;
+		}
+		if (!match[1]) {
+			errors.push({
+				file: rel,
+				message: "Missing YAML frontmatter"
+			});
+			continue;
+		}
+		let fm;
+		try {
+			fm = parse(match[1]);
+		} catch {
+			errors.push({
+				file: rel,
+				message: "Invalid YAML frontmatter"
+			});
+			continue;
+		}
+		if (!fm.name) errors.push({
+			file: rel,
+			message: "Missing required field: name"
+		});
+		if (!fm.description) errors.push({
+			file: rel,
+			message: "Missing required field: description"
+		});
+		if (typeof fm.name === "string") {
+			const expectedPath = relative(skillsDir, filePath).replace(/[/\\]SKILL\.md$/, "").split(sep).join("/");
+			if (fm.name !== expectedPath) errors.push({
+				file: rel,
+				message: `name "${fm.name}" does not match directory path "${expectedPath}"`
+			});
+		}
+		if (fm.type === "framework" && !Array.isArray(fm.requires)) errors.push({
+			file: rel,
+			message: "Framework skills must have a \"requires\" field"
+		});
+		const lineCount = content.split(/\r?\n/).length;
+		if (lineCount > 500) errors.push({
+			file: rel,
+			message: `Exceeds 500 line limit (${lineCount} lines)`
+		});
+	}
+	const artifactsDir = join(skillsDir, "_artifacts");
+	if (existsSync(artifactsDir)) for (const fileName of [
+		"domain_map.yaml",
+		"skill_spec.md",
+		"skill_tree.yaml"
+	]) {
+		const artifactPath = join(artifactsDir, fileName);
+		if (!existsSync(artifactPath)) {
+			errors.push({
+				file: relative(process.cwd(), artifactPath),
+				message: "Missing required artifact"
+			});
+			continue;
+		}
+		const content = readFileSync(artifactPath, "utf8");
+		if (content.trim().length === 0) {
+			errors.push({
+				file: relative(process.cwd(), artifactPath),
+				message: "Artifact file is empty"
+			});
+			continue;
+		}
+		if (fileName.endsWith(".yaml")) try {
+			parse(content);
+		} catch {
+			errors.push({
+				file: relative(process.cwd(), artifactPath),
+				message: "Invalid YAML in artifact file"
+			});
+		}
+	}
+	if (errors.length > 0) {
+		console.error(`\n❌ Validation failed with ${errors.length} error(s):\n`);
+		for (const { file, message } of errors) console.error(`  ${file}: ${message}`);
+		process.exit(1);
+	}
+	console.log(`✅ Validated ${skillFiles.length} skill files — all passed`);
+}
+function cmdScaffold() {
+	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 library maintainer scaffold Intent skills.
+You MUST use the Intent meta skills in this exact order and follow their output requirements.
+
+Before you start, ask the maintainer for their skills root path.
+- Default: skills/
+- If they choose a different path, replace "skills/" in all output paths below.
+
+1) Meta skill: domain-discovery
+   - Input: library name, repo URL, docs URL(s), scope constraints, target audience.
+   - Output files (exact paths):
+     - skills/_artifacts/domain_map.yaml
+     - skills/_artifacts/skill_spec.md
+   - These artifacts are maintainer-owned and should be committed to the repo.
+
+2) Meta skill: tree-generator
+   - Input: skills/_artifacts/domain_map.yaml + skills/_artifacts/skill_spec.md
+   - Output file (exact path):
+     - skills/_artifacts/skill_tree.yaml
+
+3) Meta skill: generate-skill
+   - Input: skills/_artifacts/skill_tree.yaml
+   - Output files (exact path pattern):
+     - skills/<domain>/<skill>/SKILL.md
+
+Guidance for the maintainer:
+- If any input is missing, ask for it.
+- After each step, clearly tell the maintainer what files to create and where to save them.
+- Do not skip steps.
+- Use the library's actual terminology from docs and source.
+
+At the end, produce a single Markdown feedback doc with three sections (Domain Discovery, Tree Generator, Generate Skill).
+Ask if the maintainer wants to edit it, then ask if you should send it as a GitHub issue to TanStack/intent.
+Use the issue title: [meta-feedback] intent meta skill.
+
+Finish with a short checklist:
+- Run npx intent validate
+- Commit skills/ and skills/_artifacts/ (artifacts are repo-only)
+- Exclude skills/_artifacts/ from package publishing
+- Add README snippet: If you use an AI agent, run npx intent init
+`;
+	console.log("🚀 Intent Scaffold Prompt");
+	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 CLI
+
+Usage:
+  intent list [--json]           Discover intent-enabled packages
+  intent meta                    List meta-skills for maintainers
+  intent validate [<dir>]        Validate skill files (default: skills/)
+  intent init                    Set up intent discovery in agent configs
+  intent scaffold                Print maintainer scaffold prompt
+  intent setup [--workflows] [--oz] [--all]  Copy CI/Oz templates into your repo
+  intent stale                   Check skills for staleness
+  intent feedback --submit --file <path>           Submit skill feedback
+  intent feedback --meta --submit --file <path>    Submit meta-skill feedback`;
+const command = process.argv[2];
+const commandArgs = process.argv.slice(3);
+switch (command) {
+	case "list":
+		await cmdList(commandArgs);
+		break;
+	case "meta":
+		cmdMeta();
+		break;
+	case "validate":
+		cmdValidate(commandArgs);
+		break;
+	case "init": {
+		const { runInit, detectAgentConfigs } = await import("./init-DEzzXm9j.mjs");
+		const initRoot = process.cwd();
+		const result = runInit(initRoot);
+		for (const f of result.injected) console.log(`✓ Added intent block to ${f}`);
+		for (const f of result.skipped) console.log(`  Already present in ${f}`);
+		for (const f of result.created) console.log(`✓ Created ${f}`);
+		if (result.injected.length === 0 && result.skipped.length === 0) {
+			if (detectAgentConfigs(initRoot).length === 0) {
+				console.log("No agent config files found (AGENTS.md, CLAUDE.md, .cursorrules, .github/copilot-instructions.md).");
+				console.log("Create one of these files and run intent init again.");
+			}
+		}
+		console.log(`✓ Config: ${result.configPath}`);
+		break;
+	}
+	case "scaffold":
+		cmdScaffold();
+		break;
+	case "stale": {
+		const { checkStaleness } = await import("./staleness-DyhsrqQ5.mjs");
+		const { scanForIntents: scanStale } = await import("./scanner-BuWPDJ4P.mjs");
+		let staleResult;
+		try {
+			staleResult = await scanStale();
+		} catch (err) {
+			console.error(err.message);
+			process.exit(1);
+		}
+		if (staleResult.packages.length === 0) {
+			console.log("No intent-enabled packages found.");
+			break;
+		}
+		const jsonStale = commandArgs.includes("--json");
+		const reports = await Promise.all(staleResult.packages.map((pkg) => {
+			return checkStaleness(join(process.cwd(), "node_modules", pkg.name), pkg.name);
+		}));
+		if (jsonStale) {
+			console.log(JSON.stringify(reports, null, 2));
+			break;
+		}
+		for (const report of reports) {
+			const driftLabel = report.versionDrift ? ` [${report.versionDrift} drift]` : "";
+			const vLabel = report.skillVersion && report.currentVersion ? ` (${report.skillVersion} → ${report.currentVersion})` : "";
+			console.log(`${report.library}${vLabel}${driftLabel}`);
+			const stale = report.skills.filter((s) => s.needsReview);
+			if (stale.length === 0) console.log("  All skills up-to-date");
+			else for (const skill of stale) console.log(`  ⚠ ${skill.name}: ${skill.reasons.join(", ")}`);
+			console.log();
+		}
+		break;
+	}
+	case "feedback": {
+		const { runFeedback } = await import("./feedback-FIUBOL0g.mjs");
+		runFeedback(commandArgs);
+		break;
+	}
+	case "setup": {
+		const { runSetup } = await import("./setup.mjs");
+		runSetup(process.cwd(), getMetaDir(), commandArgs);
+		break;
+	}
+	default:
+		console.log(USAGE);
+		process.exit(command ? 1 : 0);
+}
+
+//#endregion
+export {  };

package/dist/feedback-DKreHfB1.mjs

@@ -0,0 +1,300 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+
+//#region src/feedback.ts
+const META_FEEDBACK_REPO = "TanStack/intent";
+const SECRET_PATTERNS = [
+	/(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{36,}/,
+	/(?:sk|pk)[-_](?:live|test)[-_][A-Za-z0-9]{24,}/,
+	/AKIA[0-9A-Z]{16}/,
+	/-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/,
+	/eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/,
+	/(?:Bearer|token)\s+[A-Za-z0-9_\-.~+/]{20,}/i,
+	/[A-Za-z0-9]{32,}(?=.*(?:key|secret|token|password))/i
+];
+function containsSecrets(text) {
+	return SECRET_PATTERNS.some((pattern) => pattern.test(text));
+}
+function hasGhCli() {
+	try {
+		execSync("gh --version", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getHomeConfigDir() {
+	return process.env.XDG_CONFIG_HOME ?? join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".config");
+}
+function resolveFrequency(root) {
+	const userConfigPath = join(getHomeConfigDir(), "intent", "config.json");
+	try {
+		const userCfg = JSON.parse(readFileSync(userConfigPath, "utf8"));
+		if (userCfg.feedback?.frequency) return userCfg.feedback.frequency;
+	} catch {}
+	const projectConfigPath = join(root, "intent.config.json");
+	try {
+		const projCfg = JSON.parse(readFileSync(projectConfigPath, "utf8"));
+		if (projCfg.feedback?.frequency) return projCfg.feedback.frequency;
+	} catch {}
+	return "every-5";
+}
+const REQUIRED_FIELDS = [
+	"skill",
+	"package",
+	"skillVersion",
+	"task",
+	"whatWorked",
+	"whatFailed",
+	"missing",
+	"selfCorrections",
+	"userRating"
+];
+function validatePayload(payload) {
+	const errors = [];
+	if (!payload || typeof payload !== "object") return {
+		valid: false,
+		errors: ["Payload must be a JSON object"]
+	};
+	const obj = payload;
+	for (const field of REQUIRED_FIELDS) if (typeof obj[field] !== "string" || obj[field].trim() === "") errors.push(`Missing or empty required field: ${field}`);
+	if (obj.userRating && ![
+		"good",
+		"mixed",
+		"bad"
+	].includes(obj.userRating)) errors.push("userRating must be one of: good, mixed, bad");
+	if (containsSecrets(Object.values(obj).filter((v) => typeof v === "string").join("\n"))) errors.push("Payload appears to contain secrets or tokens — submission rejected");
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+const META_REQUIRED_FIELDS = [
+	"metaSkill",
+	"library",
+	"agentUsed",
+	"artifactQuality",
+	"whatWorked",
+	"whatFailed",
+	"suggestions",
+	"userRating"
+];
+const VALID_META_SKILLS = [
+	"domain-discovery",
+	"tree-generator",
+	"generate-skill",
+	"skill-staleness-check"
+];
+const VALID_AGENTS = [
+	"oz",
+	"claude-code",
+	"cursor",
+	"copilot",
+	"codex",
+	"other"
+];
+const VALID_QUALITY_RATINGS = [
+	"good",
+	"mixed",
+	"bad"
+];
+function validateMetaPayload(payload) {
+	const errors = [];
+	if (!payload || typeof payload !== "object") return {
+		valid: false,
+		errors: ["Payload must be a JSON object"]
+	};
+	const obj = payload;
+	for (const field of META_REQUIRED_FIELDS) if (typeof obj[field] !== "string" || obj[field].trim() === "") errors.push(`Missing or empty required field: ${field}`);
+	if (obj.metaSkill && !VALID_META_SKILLS.includes(obj.metaSkill)) errors.push(`metaSkill must be one of: ${VALID_META_SKILLS.join(", ")}`);
+	if (obj.agentUsed && !VALID_AGENTS.includes(obj.agentUsed)) errors.push(`agentUsed must be one of: ${VALID_AGENTS.join(", ")}`);
+	if (obj.artifactQuality && !VALID_QUALITY_RATINGS.includes(obj.artifactQuality)) errors.push("artifactQuality must be one of: good, mixed, bad");
+	if (obj.userRating && !VALID_QUALITY_RATINGS.includes(obj.userRating)) errors.push("userRating must be one of: good, mixed, bad");
+	if (containsSecrets(Object.values(obj).filter((v) => typeof v === "string").join("\n"))) errors.push("Payload appears to contain secrets or tokens — submission rejected");
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+function metaToMarkdown(payload) {
+	const lines = [
+		`# Meta-Skill Feedback: ${payload.metaSkill}`,
+		"",
+		`**Library:** ${payload.library}`,
+		`**Agent:** ${payload.agentUsed}`,
+		`**Artifact quality:** ${payload.artifactQuality}`,
+		`**Rating:** ${payload.userRating}`
+	];
+	if (payload.interviewQuality) lines.push(`**Interview quality:** ${payload.interviewQuality}`);
+	if (payload.failureModeQuality) lines.push(`**Failure mode quality:** ${payload.failureModeQuality}`);
+	lines.push("", "## What Worked", payload.whatWorked, "", "## What Failed", payload.whatFailed, "", "## Suggestions", payload.suggestions);
+	return lines.join("\n") + "\n";
+}
+function toMarkdown(payload) {
+	const lines = [
+		`# Skill Feedback: ${payload.skill}`,
+		"",
+		`**Package:** ${payload.package}`,
+		`**Skill version:** ${payload.skillVersion}`,
+		`**Rating:** ${payload.userRating}`,
+		"",
+		"## Task",
+		payload.task,
+		"",
+		"## What Worked",
+		payload.whatWorked,
+		"",
+		"## What Failed",
+		payload.whatFailed,
+		"",
+		"## Missing",
+		payload.missing,
+		"",
+		"## Self-Corrections",
+		payload.selfCorrections
+	];
+	if (payload.userComments) lines.push("", "## User Comments", payload.userComments);
+	return lines.join("\n") + "\n";
+}
+function submitFeedback(payload, repo, opts) {
+	const md = toMarkdown(payload);
+	if (opts.ghAvailable) try {
+		execSync(`gh issue create --repo ${repo} --title "${`Skill Feedback: ${payload.skill} (${payload.userRating})`.replace(/"/g, "\\\"")}" --body -`, {
+			input: md,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		return {
+			method: "gh",
+			detail: `Submitted issue to ${repo}`
+		};
+	} catch {}
+	if (opts.outputPath) {
+		writeFileSync(opts.outputPath, md, "utf8");
+		return {
+			method: "file",
+			detail: `Saved to ${opts.outputPath}`
+		};
+	}
+	return {
+		method: "stdout",
+		detail: md
+	};
+}
+function submitMetaFeedback(payload, opts) {
+	const md = metaToMarkdown(payload);
+	if (opts.ghAvailable) try {
+		execSync(`gh issue create --repo ${META_FEEDBACK_REPO} --title "${`Meta-Skill Feedback: ${payload.metaSkill} (${payload.userRating})`.replace(/"/g, "\\\"")}" --label "feedback:${payload.metaSkill}" --body -`, {
+			input: md,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		return {
+			method: "gh",
+			detail: `Submitted issue to ${META_FEEDBACK_REPO}`
+		};
+	} catch {}
+	if (opts.outputPath) {
+		writeFileSync(opts.outputPath, md, "utf8");
+		return {
+			method: "file",
+			detail: `Saved to ${opts.outputPath}`
+		};
+	}
+	return {
+		method: "stdout",
+		detail: md
+	};
+}
+function runFeedback(args) {
+	const isMeta = args.includes("--meta");
+	const submitFlag = args.includes("--submit");
+	const fileIdx = args.indexOf("--file");
+	const filePath = fileIdx !== -1 ? args[fileIdx + 1] : void 0;
+	if (!submitFlag || !filePath) {
+		if (isMeta) console.error("Usage: intent feedback --meta --submit --file <path>");
+		else console.error("Usage: intent feedback --submit --file <path>");
+		process.exit(1);
+	}
+	if (!existsSync(filePath)) {
+		console.error(`File not found: ${filePath}`);
+		process.exit(1);
+	}
+	let raw;
+	try {
+		raw = JSON.parse(readFileSync(filePath, "utf8"));
+	} catch {
+		console.error("Invalid JSON in feedback file");
+		process.exit(1);
+	}
+	const ghAvailable = hasGhCli();
+	if (resolveFrequency(process.cwd()) === "never") {
+		console.log("Feedback is disabled (frequency: never)");
+		return;
+	}
+	const dateSuffix = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	if (isMeta) {
+		const validation$1 = validateMetaPayload(raw);
+		if (!validation$1.valid) {
+			console.error("Meta-feedback validation failed:");
+			for (const err of validation$1.errors) console.error(`  - ${err}`);
+			process.exit(1);
+		}
+		const payload$1 = raw;
+		const fallbackPath$1 = `intent-meta-feedback-${dateSuffix}.md`;
+		const result$1 = submitMetaFeedback(payload$1, {
+			ghAvailable,
+			outputPath: ghAvailable ? void 0 : fallbackPath$1
+		});
+		switch (result$1.method) {
+			case "gh":
+				console.log(`✓ ${result$1.detail}`);
+				break;
+			case "file":
+				console.log(`✓ ${result$1.detail}`);
+				console.log(`Open a GitHub Discussion at https://github.com/${META_FEEDBACK_REPO}/discussions/new?category=Feedback`);
+				break;
+			case "stdout":
+				console.log("--- Meta-feedback markdown (copy/paste to discussion) ---");
+				console.log(result$1.detail);
+				break;
+		}
+		return;
+	}
+	const validation = validatePayload(raw);
+	if (!validation.valid) {
+		console.error("Feedback validation failed:");
+		for (const err of validation.errors) console.error(`  - ${err}`);
+		process.exit(1);
+	}
+	const payload = raw;
+	const repo = payload.package.replace(/^@/, "").replace(/\//, "/");
+	const fallbackPath = `intent-feedback-${dateSuffix}.md`;
+	const result = submitFeedback(payload, repo, {
+		ghAvailable,
+		outputPath: ghAvailable ? void 0 : fallbackPath
+	});
+	switch (result.method) {
+		case "gh":
+			console.log(`✓ ${result.detail}`);
+			break;
+		case "file":
+			console.log(`✓ ${result.detail}`);
+			console.log("You can manually open an issue with this content.");
+			break;
+		case "stdout":
+			console.log("--- Feedback markdown (copy/paste to issue) ---");
+			console.log(result.detail);
+			break;
+	}
+}
+
+//#endregion
+export { runFeedback as a, toMarkdown as c, resolveFrequency as i, validateMetaPayload as l, hasGhCli as n, submitFeedback as o, metaToMarkdown as r, submitMetaFeedback as s, containsSecrets as t, validatePayload as u };

package/dist/feedback-FIUBOL0g.mjs

@@ -0,0 +1,3 @@
+import { a as runFeedback, 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";
+
+export { runFeedback };