@tanstack/intent 0.0.44 → 0.1.1

package/README.md

@@ -117,8 +117,6 @@ npx @tanstack/intent@latest setup
 
 The real risk with any derived artifact is staleness. `npx @tanstack/intent@latest stale` flags skills whose source docs have changed, generated skills that drift from `_artifacts`, and public workspace packages missing coverage. CI templates catch drift before it ships.
 
-The feedback loop runs both directions. `npx @tanstack/intent@latest feedback` lets users submit structured reports when a skill produces wrong output — which skill, which version, what broke. That context flows back to the maintainer, and the fix ships to everyone on the next package update. Every support interaction produces an artifact that prevents the same class of problem for all future users — not just the one who reported it.
-
 ## CLI Commands
 
 | Command                                            | Description                                         |
@@ -131,7 +129,6 @@ The feedback loop runs both directions. `npx @tanstack/intent@latest feedback` l
 | `npx @tanstack/intent@latest validate [dir]`       | Validate SKILL.md files                             |
 | `npx @tanstack/intent@latest setup`                | Copy CI templates into your repo                    |
 | `npx @tanstack/intent@latest stale [dir] [--json]` | Check skills for version drift                      |
-| `npx @tanstack/intent@latest feedback`             | Submit skill feedback                               |
 
 ## License
 

package/dist/artifact-coverage-BfJ7f-S9.mjs

@@ -0,0 +1,3 @@
+import { t as readIntentArtifacts } from "./artifact-coverage-nGwun1tt.mjs";
+
+export { readIntentArtifacts };

package/dist/cli-support-BADtMg6z.mjs

@@ -0,0 +1,6 @@
+import "./utils-Dj49bkF_.mjs";
+import "./workspace-patterns-Cz_lNhwz.mjs";
+import "./project-context-DDCie6Ro.mjs";
+import { a as noticeOptionsFromGlobalFlags, c as scanIntentsOrFail, i as getMetaDir, l as printNotices, n as coreOptionsFromGlobalFlags, o as printDebugInfo, r as getCheckSkillsWorkflowAdvisories, s as resolveStaleTargets, t as INTENT_CHECK_SKILLS_WORKFLOW_VERSION, u as printWarnings } from "./cli-support-C8SKYTA4.mjs";
+
+export { INTENT_CHECK_SKILLS_WORKFLOW_VERSION, coreOptionsFromGlobalFlags, getCheckSkillsWorkflowAdvisories, getMetaDir, noticeOptionsFromGlobalFlags, printDebugInfo, printNotices, printWarnings, resolveStaleTargets, scanIntentsOrFail };

package/dist/{cli-support-BNDR3l1g.mjs → cli-support-C8SKYTA4.mjs}

@@ -1,4 +1,4 @@
-import { t as resolveProjectContext } from "./project-context-BRIMzhi4.mjs";
+import { t as resolveProjectContext } from "./project-context-DDCie6Ro.mjs";
 import { t as fail } from "./cli-error-BrMXlbtx.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
@@ -10,6 +10,25 @@ function printWarnings(warnings) {
 	console.log("Warnings:");
 	for (const warning of warnings) console.log(`  ⚠ ${warning}`);
 }
+const TRUE_LIKE_VALUES = new Set([
+	"1",
+	"true",
+	"yes",
+	"on"
+]);
+function envSuppressesNotices() {
+	const value = process.env.INTENT_NO_NOTICES?.trim().toLowerCase();
+	return value ? TRUE_LIKE_VALUES.has(value) : false;
+}
+function shouldSuppressNotices(options = {}) {
+	return options.noNotices === true || envSuppressesNotices();
+}
+function printNotices(notices, options = {}) {
+	if (notices.length === 0) return;
+	if (shouldSuppressNotices(options)) return;
+	console.error("Notices:");
+	for (const notice of notices) console.error(`  ℹ ${notice}`);
+}
 
 //#endregion
 //#region src/cli-support.ts
@@ -30,10 +49,15 @@ function getCheckSkillsWorkflowAdvisories(root) {
 	if ((versionMatch ? Number(versionMatch[1]) : 0) >= INTENT_CHECK_SKILLS_WORKFLOW_VERSION) return [];
 	return [`Intent workflow update available: run \`npx @tanstack/intent@latest setup\` to refresh ${relative(process.cwd(), workflowPath) || workflowPath}.`];
 }
-async function scanIntentsOrFail(options) {
-	const { scanForIntents } = await import("./scanner-BV7X5n_z.mjs");
+async function scanIntentsOrFail(coreOptions = {}) {
+	const { scanForPolicedIntents } = await import("./source-policy-D4slvwwI.mjs");
 	try {
-		return scanForIntents(void 0, options);
+		const { scan } = scanForPolicedIntents({
+			cwd: process.cwd(),
+			scanOptions: scanOptionsFromGlobalFlags(coreOptions),
+			coreOptions
+		});
+		return scan;
 	} catch (err) {
 		fail(err instanceof Error ? err.message : String(err));
 	}
@@ -48,11 +72,13 @@ function coreOptionsFromGlobalFlags(options) {
 	if (options.global && options.globalOnly) fail("Use either --global or --global-only, not both.");
 	return {
 		debug: options.debug,
-		exclude: Array.isArray(options.exclude) ? options.exclude : options.exclude ? [options.exclude] : void 0,
 		global: options.global,
 		globalOnly: options.globalOnly
 	};
 }
+function noticeOptionsFromGlobalFlags(options) {
+	return { noNotices: options.noNotices || options.notices === false };
+}
 function formatDebugValue(value) {
 	if (Array.isArray(value)) return value.length > 0 ? value.join(", ") : "(none)";
 	return String(value);
@@ -68,18 +94,18 @@ async function resolveStaleTargets(targetDir) {
 		targetPath: targetDir
 	});
 	const workflowAdvisories = getCheckSkillsWorkflowAdvisories(context.workspaceRoot ?? context.packageRoot ?? resolvedRoot);
-	const { buildWorkspaceCoverageSignals, checkStaleness, readPackageName } = await import("./staleness-CB3qpVCq.mjs");
+	const { buildWorkspaceCoverageSignals, checkStaleness, readPackageName } = await import("./staleness-Ctzy2Zac.mjs");
 	const isWorkspaceRootTarget = context.workspaceRoot !== null && resolvedRoot === context.workspaceRoot;
 	if (context.packageRoot && !isWorkspaceRootTarget && (context.targetSkillsDir !== null || context.workspaceRoot === null)) return {
 		reports: [await checkStaleness(context.packageRoot, readPackageName(context.packageRoot), context.workspaceRoot ?? context.packageRoot)],
 		workflowAdvisories
 	};
-	const { findWorkspaceRoot, getWorkspaceInfo } = await import("./workspace-patterns-Bjq_cXww.mjs");
+	const { findWorkspaceRoot, getWorkspaceInfo } = await import("./workspace-patterns-BBW4c1gr.mjs");
 	const workspaceRoot = findWorkspaceRoot(resolvedRoot);
 	const workspaceInfo = workspaceRoot ? getWorkspaceInfo(workspaceRoot) : null;
 	if (workspaceInfo) {
 		const reports = await Promise.all(workspaceInfo.packageDirsWithSkills.map((packageDir) => checkStaleness(packageDir, readPackageName(packageDir), workspaceInfo.root)));
-		const { readIntentArtifacts } = await import("./artifact-coverage-DA26utB1.mjs");
+		const { readIntentArtifacts } = await import("./artifact-coverage-BfJ7f-S9.mjs");
 		const artifacts = existsSync(join(workspaceInfo.root, "_artifacts")) ? readIntentArtifacts(workspaceInfo.root) : null;
 		const coverageSignals = buildWorkspaceCoverageSignals({
 			artifactRoot: workspaceInfo.root,
@@ -111,4 +137,4 @@ async function resolveStaleTargets(targetDir) {
 }
 
 //#endregion
-export { printDebugInfo as a, scanOptionsFromGlobalFlags as c, getMetaDir as i, printWarnings as l, coreOptionsFromGlobalFlags as n, resolveStaleTargets as o, getCheckSkillsWorkflowAdvisories as r, scanIntentsOrFail as s, INTENT_CHECK_SKILLS_WORKFLOW_VERSION as t };
+export { noticeOptionsFromGlobalFlags as a, scanIntentsOrFail as c, getMetaDir as i, printNotices as l, coreOptionsFromGlobalFlags as n, printDebugInfo as o, getCheckSkillsWorkflowAdvisories as r, resolveStaleTargets as s, INTENT_CHECK_SKILLS_WORKFLOW_VERSION as t, printWarnings as u };

package/dist/cli.mjs

@@ -8,44 +8,48 @@ import { cac } from "cac";
 function createCli() {
 	const cli = cac("intent");
 	cli.usage("<command> [options]");
-	cli.command("list", "Discover intent-enabled packages from the project or workspace").usage("list [--json] [--debug] [--exclude <pattern>] [--global] [--global-only]").option("--json", "Output JSON").option("--debug", "Print discovery debug details to stderr").option("--exclude <pattern>", "Exclude package name glob").option("--global", "Include global packages after project packages").option("--global-only", "List global packages only").example("list").example("list --json").example("list --global").action(async (options) => {
-		const { runListCommand } = await import("./list-DrChOziX.mjs");
+	cli.command("list", "Discover intent-enabled packages from the project or workspace").usage("list [--json] [--debug] [--global] [--global-only] [--no-notices]").option("--json", "Output JSON").option("--debug", "Print discovery debug details to stderr").option("--global", "Include global packages after project packages").option("--global-only", "List global packages only").option("--no-notices", "Suppress non-critical notices on stderr").example("list").example("list --json").example("list --global").action(async (options) => {
+		const { runListCommand } = await import("./list-UqYivAcV.mjs");
 		await runListCommand(options);
 	});
-	cli.command("load [use]", "Load a compact skill use and print its SKILL.md").usage("load <use> [--path] [--json] [--debug] [--exclude <pattern>] [--global] [--global-only]").option("--path", "Print the resolved skill path instead of file content").option("--json", "Output JSON").option("--debug", "Print resolution debug details to stderr").option("--exclude <pattern>", "Exclude package name glob").option("--global", "Load from project packages, then global packages").option("--global-only", "Load from global packages only").example("load @tanstack/query#core").example("load @tanstack/query#core --path").action(async (use, options) => {
-		const { runLoadCommand } = await import("./load-ll7s5E3J.mjs");
+	cli.command("exclude [action] [pattern]", "Manage package.json intent.exclude entries").usage("exclude [list|add|remove] [pattern] [--json]").option("--json", "Output JSON list of configured exclude patterns").example("exclude").example("exclude list --json").example("exclude add @tanstack/router#experimental-*").example("exclude remove @tanstack/router#experimental-*").action(async (action, pattern, options) => {
+		const { runExcludeCommand } = await import("./exclude-CBxkyK3Q.mjs");
+		await runExcludeCommand(action, pattern, options);
+	});
+	cli.command("load [use]", "Load a compact skill use and print its SKILL.md").usage("load <use> [--path] [--json] [--debug] [--global] [--global-only]").option("--path", "Print the resolved skill path instead of file content").option("--json", "Output JSON").option("--debug", "Print resolution debug details to stderr").option("--global", "Load from project packages, then global packages").option("--global-only", "Load from global packages only").example("load @tanstack/query#core").example("load @tanstack/query#core --path").action(async (use, options) => {
+		const { runLoadCommand } = await import("./load-Dgw151E3.mjs");
 		await runLoadCommand(use, options);
 	});
 	cli.command("meta [name]", "List meta-skills, or print one by name").usage("meta [name]").example("meta").example("meta domain-discovery").action(async (name) => {
-		const [{ getMetaDir }, { runMetaCommand }] = await Promise.all([import("./cli-support-BtHFD7gl.mjs"), import("./meta-BEJIfnPG.mjs")]);
+		const [{ getMetaDir }, { runMetaCommand }] = await Promise.all([import("./cli-support-BADtMg6z.mjs"), import("./meta-BZMVgIzJ.mjs")]);
 		await runMetaCommand(name, getMetaDir());
 	});
 	cli.command("validate [dir]", "Validate skill files").usage("validate [dir] [--github-summary]").option("--github-summary", "Write a GitHub Actions step summary").example("validate").example("validate packages/query/skills").action(async (dir, options) => {
-		const { runValidateCommand } = await import("./validate-CEhp9gDs.mjs");
+		const { runValidateCommand } = await import("./validate-B3pkTIZl.mjs");
 		await runValidateCommand(dir, options);
 	});
-	cli.command("install", "Create or update skill loading guidance in an agent config file").usage("install [--map] [--dry-run] [--print-prompt] [--global] [--global-only]").option("--map", "Write explicit skill-to-task mappings").option("--dry-run", "Print the generated block without writing").option("--print-prompt", "Print the legacy agent setup prompt instead of writing").option("--global", "Include global packages after project packages").option("--global-only", "Install mappings from global packages only").example("install").example("install --map").example("install --dry-run").example("install --print-prompt").example("install --global").action(async (options) => {
-		const [{ scanIntentsOrFail }, { runInstallCommand }] = await Promise.all([import("./cli-support-BtHFD7gl.mjs"), import("./install-D1dsnbr9.mjs")]);
+	cli.command("install", "Create or update skill loading guidance in an agent config file").usage("install [--map] [--dry-run] [--print-prompt] [--global] [--global-only] [--no-notices]").option("--map", "Write explicit skill-to-task mappings").option("--dry-run", "Print the generated block without writing").option("--print-prompt", "Print the legacy agent setup prompt instead of writing").option("--global", "Include global packages after project packages").option("--global-only", "Install mappings from global packages only").option("--no-notices", "Suppress non-critical notices on stderr").example("install").example("install --map").example("install --dry-run").example("install --print-prompt").example("install --global").action(async (options) => {
+		const [{ scanIntentsOrFail }, { runInstallCommand }] = await Promise.all([import("./cli-support-BADtMg6z.mjs"), import("./install-BE7gVoNT.mjs")]);
 		await runInstallCommand(options, scanIntentsOrFail);
 	});
 	cli.command("scaffold", "Print maintainer scaffold prompt").usage("scaffold").action(async () => {
-		const [{ getMetaDir }, { runScaffoldCommand }] = await Promise.all([import("./cli-support-BtHFD7gl.mjs"), import("./scaffold-CLM6bt3c.mjs")]);
+		const [{ getMetaDir }, { runScaffoldCommand }] = await Promise.all([import("./cli-support-BADtMg6z.mjs"), import("./scaffold-D2vwv9ls.mjs")]);
 		runScaffoldCommand(getMetaDir());
 	});
 	cli.command("stale [dir]", "Check skills for staleness in the current package or workspace").usage("stale [dir] [--json] [--github-review]").option("--json", "Output JSON").option("--github-review", "Write GitHub Actions review PR files").option("--package-label <label>", "Fallback package label for review PRs").example("stale").example("stale packages/query").example("stale --json").action(async (targetDir, options) => {
-		const [{ resolveStaleTargets }, { runStaleCommand }] = await Promise.all([import("./cli-support-BtHFD7gl.mjs"), import("./stale-C6dPKQ98.mjs")]);
+		const [{ resolveStaleTargets }, { runStaleCommand }] = await Promise.all([import("./cli-support-BADtMg6z.mjs"), import("./stale-DxZyYibt.mjs")]);
 		await runStaleCommand(targetDir, options, resolveStaleTargets);
 	});
 	cli.command("edit-package-json", "Update package.json files so skills are published").usage("edit-package-json").action(async () => {
-		const { runEditPackageJsonCommand } = await import("./edit-package-json-CtuelQ_q.mjs");
+		const { runEditPackageJsonCommand } = await import("./edit-package-json-DKyJ04t1.mjs");
 		await runEditPackageJsonCommand(process.cwd());
 	});
 	cli.command("setup", "Copy Intent CI workflow templates into .github/workflows/").usage("setup").action(async () => {
-		const [{ getMetaDir }, { runSetupGithubActionsCommand }] = await Promise.all([import("./cli-support-BtHFD7gl.mjs"), import("./setup-github-actions-CUd1oncY.mjs")]);
+		const [{ getMetaDir }, { runSetupGithubActionsCommand }] = await Promise.all([import("./cli-support-BADtMg6z.mjs"), import("./setup-github-actions-emXSyGy3.mjs")]);
 		await runSetupGithubActionsCommand(process.cwd(), getMetaDir());
 	});
 	cli.command("setup-github-actions", "Copy Intent CI workflow templates into .github/workflows/").usage("setup-github-actions").action(async () => {
-		const [{ getMetaDir }, { runSetupGithubActionsCommand }] = await Promise.all([import("./cli-support-BtHFD7gl.mjs"), import("./setup-github-actions-CUd1oncY.mjs")]);
+		const [{ getMetaDir }, { runSetupGithubActionsCommand }] = await Promise.all([import("./cli-support-BADtMg6z.mjs"), import("./setup-github-actions-emXSyGy3.mjs")]);
 		await runSetupGithubActionsCommand(process.cwd(), getMetaDir());
 	});
 	cli.command("help [command]", "Display help for a command").action((commandName) => {

package/dist/{core-qlBI_aQL.mjs → core-hEMP5GMV.mjs}

@@ -1,9 +1,11 @@
-import { i as getDeps, l as resolveDepDir, u as toPosixPath } from "./utils-9fhWAVua.mjs";
-import { n as scanIntentPackageAtRoot, r as createIntentFsCache, t as scanForIntents } from "./scanner-DaG82zNc.mjs";
-import { n as findWorkspacePackages } from "./workspace-patterns-BffPlZ1D.mjs";
-import { i as parseSkillUse, n as formatSkillUse } from "./skill-use-umYvZl94.mjs";
-import { t as resolveProjectContext } from "./project-context-BRIMzhi4.mjs";
-import { a as compileExcludePatterns, c as warningMentionsPackage, i as resolveSkillUse, o as getEffectiveExcludePatterns, r as resolveSkillEntry, s as isPackageExcluded, t as ResolveSkillUseError } from "./resolver-D9cjsz11.mjs";
+import { d as toPosixPath, i as getDeps, u as resolveDepDir } from "./utils-Dj49bkF_.mjs";
+import { n as scanIntentPackageAtRoot, r as createIntentFsCache } from "./scanner-2XDBAsbm.mjs";
+import { n as findWorkspacePackages } from "./workspace-patterns-Cz_lNhwz.mjs";
+import { i as parseSkillUse, n as formatSkillUse } from "./skill-use-CUrNHf-u.mjs";
+import { t as resolveProjectContext } from "./project-context-DDCie6Ro.mjs";
+import { o as warningMentionsPackage, r as getEffectiveExcludePatterns, t as compileExcludePatterns } from "./excludes-DDMe-4iu.mjs";
+import { i as resolveSkillUse, r as resolveSkillEntry, t as ResolveSkillUseError } from "./resolver-CZXZ0rft.mjs";
+import { a as checkLoadAllowed, o as readSkillSourcesConfig, s as scanForPolicedIntents } from "./source-policy-rGOtjQSM.mjs";
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 
@@ -361,11 +363,13 @@ function listIntentSkills(options = {}) {
 	const scanOptions = toScanOptions(options);
 	const fsCache = createIntentFsCache();
 	const projectContext = resolveProjectContext({ cwd });
-	const scanResult = scanForIntents(cwd, withFsCache(scanOptions, fsCache));
-	const excludePatterns = getEffectiveExcludePatterns(options, projectContext);
-	const excludeMatchers = compileExcludePatterns(excludePatterns);
-	const excludedPackages = scanResult.packages.filter((pkg) => isPackageExcluded(pkg.name, excludeMatchers)).map((pkg) => pkg.name);
-	const packages = scanResult.packages.filter((pkg) => !isPackageExcluded(pkg.name, excludeMatchers));
+	const { scan, excludePatterns } = scanForPolicedIntents({
+		cwd,
+		scanOptions: withFsCache(scanOptions, fsCache),
+		coreOptions: options,
+		context: projectContext
+	});
+	const packages = scan.packages;
 	const skills = packages.flatMap((pkg) => pkg.skills.map((skill) => {
 		return {
 			use: formatSkillUse(pkg.name, skill.name),
@@ -380,7 +384,7 @@ function listIntentSkills(options = {}) {
 		};
 	}));
 	const result = {
-		packageManager: scanResult.packageManager,
+		packageManager: scan.packageManager,
 		skills,
 		packages: packages.map((pkg) => ({
 			name: pkg.name,
@@ -389,8 +393,9 @@ function listIntentSkills(options = {}) {
 			packageRoot: pkg.packageRoot,
 			skillCount: pkg.skills.length
 		})),
-		warnings: scanResult.warnings.filter((warning) => !excludedPackages.some((packageName) => warningMentionsPackage(warning, packageName))),
-		conflicts: scanResult.conflicts.filter((conflict) => !isPackageExcluded(conflict.packageName, excludeMatchers))
+		warnings: scan.warnings,
+		notices: scan.notices,
+		conflicts: scan.conflicts
 	};
 	if (options.debug) result.debug = {
 		cwd,
@@ -399,8 +404,9 @@ function listIntentSkills(options = {}) {
 		packageCount: result.packages.length,
 		skillCount: result.skills.length,
 		warningCount: result.warnings.length,
+		noticeCount: result.notices.length,
 		conflictCount: result.conflicts.length,
-		scan: scanResult.stats ?? fsCache.getStats()
+		scan: scan.stats ?? fsCache.getStats()
 	};
 	return result;
 }
@@ -464,7 +470,12 @@ function resolveIntentSkillInCwd(cwd, use, options = {}) {
 	const projectContext = resolveProjectContext({ cwd });
 	const excludePatterns = getEffectiveExcludePatterns(options, projectContext);
 	const excludeMatchers = compileExcludePatterns(excludePatterns);
-	if (isPackageExcluded(parsedUse.packageName, excludeMatchers)) throw new IntentCoreError("package-excluded", `Cannot load skill use "${use}": package "${parsedUse.packageName}" is excluded by Intent configuration.`);
+	const config = readSkillSourcesConfig(cwd, projectContext);
+	const refusal = checkLoadAllowed(use, parsedUse, {
+		config,
+		excludeMatchers
+	});
+	if (refusal) throw new IntentCoreError(refusal.code, refusal.message);
 	const scanOptions = toScanOptions(options);
 	const scope = getScanScope(scanOptions);
 	const fastPathResolved = resolveSkillUseFastPath(parsedUse, options, projectContext, cwd, fsCache);
@@ -476,7 +487,12 @@ function resolveIntentSkillInCwd(cwd, use, options = {}) {
 		scan: fsCache.getStats(),
 		scope
 	}) : void 0);
-	const scanResult = scanForIntents(cwd, withFsCache(scanOptions, fsCache));
+	const { scan: scanResult } = scanForPolicedIntents({
+		cwd,
+		scanOptions: withFsCache(scanOptions, fsCache),
+		coreOptions: options,
+		context: projectContext
+	});
 	let resolved;
 	try {
 		resolved = resolveSkillUse(use, scanResult);

package/dist/core.d.mts

@@ -1,4 +1,4 @@
-import { S as VersionConflict, _ as ScanStats, g as ScanScope, l as IntentPackage, p as PackageManager } from "./types-CIha6LtJ.mjs";
+import { _ as VersionConflict, c as PackageManager, d as ScanScope, f as ScanStats, s as IntentPackage } from "./types-oEflMSso.mjs";
 
 //#region src/core/types.d.ts
 interface IntentCoreOptions {
@@ -31,6 +31,7 @@ interface IntentSkillList {
   skills: Array<IntentSkillSummary>;
   packages: Array<IntentPackageSummary>;
   warnings: Array<string>;
+  notices: Array<string>;
   conflicts: Array<VersionConflict>;
   debug?: IntentSkillListDebug;
 }
@@ -55,6 +56,7 @@ interface IntentSkillListDebug {
   packageCount: number;
   skillCount: number;
   warningCount: number;
+  noticeCount: number;
   conflictCount: number;
   scan: IntentScanDebugStats;
 }
@@ -72,7 +74,7 @@ interface LoadedIntentSkillDebug {
   scan: IntentScanDebugStats;
 }
 interface IntentScanDebugStats extends ScanStats {}
-type IntentCoreErrorCode = 'invalid-options' | 'invalid-skill-use' | 'package-not-found' | 'package-excluded' | 'skill-not-found' | 'skill-path-outside-package' | 'skill-file-not-found';
+type IntentCoreErrorCode = 'invalid-options' | 'invalid-skill-use' | 'package-not-found' | 'package-excluded' | 'package-not-listed' | 'skill-excluded' | 'skill-not-found' | 'skill-path-outside-package' | 'skill-file-not-found';
 //#endregion
 //#region src/core.d.ts
 declare class IntentCoreError extends Error {

package/dist/core.mjs

@@ -1,9 +1,11 @@
-import "./utils-9fhWAVua.mjs";
-import "./skill-paths-B-j0dWDA.mjs";
-import "./scanner-DaG82zNc.mjs";
-import "./workspace-patterns-BffPlZ1D.mjs";
-import "./project-context-BRIMzhi4.mjs";
-import "./resolver-D9cjsz11.mjs";
-import { i as resolveIntentSkill, n as listIntentSkills, r as loadIntentSkill, t as IntentCoreError } from "./core-qlBI_aQL.mjs";
+import "./utils-Dj49bkF_.mjs";
+import "./skill-paths-Cr74uFk4.mjs";
+import "./scanner-2XDBAsbm.mjs";
+import "./workspace-patterns-Cz_lNhwz.mjs";
+import "./project-context-DDCie6Ro.mjs";
+import "./excludes-DDMe-4iu.mjs";
+import "./resolver-CZXZ0rft.mjs";
+import { i as resolveIntentSkill, n as listIntentSkills, r as loadIntentSkill, t as IntentCoreError } from "./core-hEMP5GMV.mjs";
+import "./source-policy-rGOtjQSM.mjs";
 
 export { IntentCoreError, listIntentSkills, loadIntentSkill, resolveIntentSkill };

package/dist/{display-0FnzlKRq.mjs → display-CFnFnrtx.mjs}

@@ -1,5 +1,5 @@
-import "./utils-9fhWAVua.mjs";
-import { n as isStableLoadPath, t as formatRuntimeSkillLookupHint } from "./skill-paths-B-j0dWDA.mjs";
+import "./utils-Dj49bkF_.mjs";
+import { n as isStableLoadPath, t as formatRuntimeSkillLookupHint } from "./skill-paths-Cr74uFk4.mjs";
 
 //#region src/display.ts
 function padColumn(text, width) {

package/dist/exclude-CBxkyK3Q.mjs

@@ -0,0 +1,126 @@
+import "./utils-Dj49bkF_.mjs";
+import "./workspace-patterns-Cz_lNhwz.mjs";
+import "./project-context-DDCie6Ro.mjs";
+import { t as compileExcludePatterns } from "./excludes-DDMe-4iu.mjs";
+import { t as fail } from "./cli-error-BrMXlbtx.mjs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/commands/exclude.ts
+function normalizeAction(action) {
+	if (!action) return "list";
+	if (action === "list" || action === "add" || action === "remove") return action;
+	fail(`Unknown exclude action: ${action}. Expected list, add, or remove.`);
+}
+function getPackageJsonPath(cwd) {
+	return join(cwd, "package.json");
+}
+function readPackageJson(cwd) {
+	const packageJsonPath = getPackageJsonPath(cwd);
+	if (!existsSync(packageJsonPath)) fail(`No package.json found in ${cwd}`);
+	try {
+		return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+	} catch (err) {
+		fail(`Failed to parse ${packageJsonPath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+function readConfiguredExcludes(pkg) {
+	const intent = pkg.intent;
+	if (intent === void 0) return [];
+	if (!intent || typeof intent !== "object") fail("Invalid package.json: intent must be an object when present.");
+	const raw = intent.exclude;
+	if (raw === void 0) return [];
+	if (!Array.isArray(raw)) fail("Invalid package.json: intent.exclude must be an array of strings.");
+	const excludes = [];
+	for (const entry of raw) {
+		if (typeof entry !== "string") fail("Invalid package.json: intent.exclude must contain only strings.");
+		const trimmed = entry.trim();
+		if (trimmed.length === 0) continue;
+		excludes.push(trimmed);
+	}
+	return excludes;
+}
+function setConfiguredExcludes(pkg, excludes) {
+	const intent = pkg.intent && typeof pkg.intent === "object" ? pkg.intent : {};
+	intent.exclude = excludes;
+	pkg.intent = intent;
+}
+function writePackageJson(cwd, pkg) {
+	writeFileSync(getPackageJsonPath(cwd), `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
+}
+function normalizePattern(pattern, action) {
+	if (!pattern) fail(`Missing exclude pattern. Expected: intent exclude ${action} <pattern>`);
+	const trimmed = pattern.trim();
+	if (trimmed.length === 0) fail(`Missing exclude pattern. Expected: intent exclude ${action} <pattern>`);
+	return trimmed;
+}
+function validatePattern(pattern) {
+	try {
+		compileExcludePatterns([pattern]);
+	} catch (err) {
+		fail(`Invalid exclude pattern "${pattern}": ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+function printExcludes(excludes, json) {
+	if (json) {
+		console.log(JSON.stringify(excludes, null, 2));
+		return;
+	}
+	if (excludes.length === 0) {
+		console.log("No excludes configured.");
+		return;
+	}
+	console.log("Configured excludes:");
+	for (const pattern of excludes) console.log(`- ${pattern}`);
+}
+async function runExcludeCommand(actionArg, patternArg, options) {
+	const action = normalizeAction(actionArg);
+	const cwd = process.cwd();
+	const pkg = readPackageJson(cwd);
+	const currentExcludes = readConfiguredExcludes(pkg);
+	if (action === "list") {
+		if (patternArg) fail("Unexpected pattern for list. Use: intent exclude list [--json]");
+		printExcludes(currentExcludes, options.json);
+		return;
+	}
+	const pattern = normalizePattern(patternArg, action);
+	validatePattern(pattern);
+	if (action === "add") {
+		if (currentExcludes.includes(pattern)) {
+			if (options.json) {
+				printExcludes(currentExcludes, true);
+				return;
+			}
+			console.log(`Exclude pattern "${pattern}" is already configured.`);
+			return;
+		}
+		const updated$1 = [...currentExcludes, pattern];
+		setConfiguredExcludes(pkg, updated$1);
+		writePackageJson(cwd, pkg);
+		if (options.json) {
+			printExcludes(updated$1, true);
+			return;
+		}
+		console.log(`Added exclude pattern "${pattern}" to package.json intent.exclude.`);
+		return;
+	}
+	const updated = currentExcludes.filter((value) => value !== pattern);
+	if (updated.length === currentExcludes.length) {
+		if (options.json) {
+			printExcludes(currentExcludes, true);
+			return;
+		}
+		console.log(`Exclude pattern "${pattern}" is not configured.`);
+		return;
+	}
+	setConfiguredExcludes(pkg, updated);
+	writePackageJson(cwd, pkg);
+	if (options.json) {
+		printExcludes(updated, true);
+		return;
+	}
+	console.log(`Removed exclude pattern "${pattern}" from package.json intent.exclude.`);
+}
+
+//#endregion
+export { runExcludeCommand };

package/dist/excludes-DDMe-4iu.mjs

@@ -0,0 +1,111 @@
+import { t as resolveProjectContext } from "./project-context-DDCie6Ro.mjs";
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+//#region src/core/package-json.ts
+function readPackageJson(dir) {
+	try {
+		return JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/core/excludes.ts
+const MAX_EXCLUDE_PATTERN_LENGTH = 200;
+const PACKAGE_NAME_BOUNDARY = /[^a-zA-Z0-9_.-]/;
+function normalizeExcludePatterns(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((pattern) => typeof pattern === "string").map((pattern) => pattern.trim()).filter(Boolean);
+}
+function isWithinOrEqual(path, parentDir) {
+	const rel = relative(parentDir, path);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function readPackageExcludes(dir) {
+	const intent = readPackageJson(dir)?.intent;
+	if (!intent || typeof intent !== "object") return [];
+	return normalizeExcludePatterns(intent.exclude);
+}
+function getConfigDirs(cwd, context = resolveProjectContext({ cwd })) {
+	const root = context.workspaceRoot ?? context.packageRoot ?? cwd;
+	const dirs = [];
+	let dir = cwd;
+	while (isWithinOrEqual(dir, root)) {
+		dirs.push(dir);
+		if (dir === root) break;
+		const next = dirname(dir);
+		if (next === dir) break;
+		dir = next;
+	}
+	return dirs;
+}
+function getConfigExcludePatterns(cwd, context = resolveProjectContext({ cwd })) {
+	return [...getConfigDirs(cwd, context)].reverse().flatMap(readPackageExcludes);
+}
+function getEffectiveExcludePatterns(options = {}, context) {
+	return [...getConfigExcludePatterns(context?.cwd ?? resolve(process.cwd(), options.cwd ?? process.cwd()), context), ...normalizeExcludePatterns(options.exclude)];
+}
+function assertPatternLength(pattern) {
+	if (pattern.length > MAX_EXCLUDE_PATTERN_LENGTH) throw new Error(`Intent exclude pattern is too long: ${pattern.length} characters. Maximum is ${MAX_EXCLUDE_PATTERN_LENGTH}.`);
+}
+function globToRegExp(pattern) {
+	const source = pattern.replace(/\*+/g, "*").split("*").map((part) => part.replace(/[\\^$+?.()|[\]{}]/g, "\\$&")).join(".*");
+	return /* @__PURE__ */ new RegExp(`^${source}$`);
+}
+function compileSegment(segment) {
+	if (!segment.includes("*")) return (value) => value === segment;
+	const regex = globToRegExp(segment);
+	return (value) => regex.test(value);
+}
+function compileExcludePatterns(patterns) {
+	return patterns.map((pattern) => {
+		assertPatternLength(pattern);
+		const hashIndex = pattern.indexOf("#");
+		if (hashIndex === -1) return {
+			pattern,
+			matchesPackage: compileSegment(pattern)
+		};
+		const packageSegment = pattern.slice(0, hashIndex);
+		const skillSegment = pattern.slice(hashIndex + 1);
+		if (skillSegment.replace(/\*+/g, "*") === "*") return {
+			pattern,
+			matchesPackage: compileSegment(packageSegment)
+		};
+		return {
+			pattern,
+			matchesPackage: compileSegment(packageSegment),
+			matchesSkill: compileSegment(skillSegment)
+		};
+	});
+}
+function isPackageExcluded(packageName, matchers) {
+	return matchers.some((matcher) => matcher.matchesSkill === void 0 && matcher.matchesPackage(packageName));
+}
+function skillNameVariants(packageName, skillName) {
+	const prefix = `${packageName.split("/").pop() ?? packageName}/`;
+	if (skillName.startsWith(prefix)) return [skillName, skillName.slice(prefix.length)];
+	return [skillName, `${prefix}${skillName}`];
+}
+function isSkillExcluded(packageName, skillName, matchers) {
+	const variants = skillNameVariants(packageName, skillName);
+	return matchers.some((matcher) => {
+		if (!matcher.matchesPackage(packageName)) return false;
+		if (matcher.matchesSkill === void 0) return true;
+		return variants.some((variant) => matcher.matchesSkill(variant));
+	});
+}
+function warningMentionsPackage(warning, packageName) {
+	let idx = warning.indexOf(packageName);
+	while (idx !== -1) {
+		const before = warning[idx - 1];
+		const after = warning[idx + packageName.length];
+		if ((before === void 0 || PACKAGE_NAME_BOUNDARY.test(before)) && (after === void 0 || PACKAGE_NAME_BOUNDARY.test(after))) return true;
+		idx = warning.indexOf(packageName, idx + packageName.length);
+	}
+	return false;
+}
+
+//#endregion
+export { isSkillExcluded as a, isPackageExcluded as i, getConfigDirs as n, warningMentionsPackage as o, getEffectiveExcludePatterns as r, readPackageJson as s, compileExcludePatterns as t };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { S as VersionConflict, a as IntentArtifactSet, b as StalenessReport, c as IntentConfig, d as MetaFeedbackPayload, f as MetaSkillName, h as ScanResult, i as IntentArtifactFile, l as IntentPackage, m as ScanOptions, n as FeedbackPayload, o as IntentArtifactSkill, r as IntentArtifactCoverageIgnore, s as IntentArtifactWarning, t as AgentName, u as IntentProjectConfig, v as SkillEntry, x as StalenessSignal, y as SkillStaleness } from "./types-CIha6LtJ.mjs";
-import { i as runEditPackageJson, o as runSetupGithubActions, r as SetupGithubActionsResult, t as EditPackageJsonResult } from "./setup-DhMqESd3.mjs";
+import { _ as VersionConflict, a as IntentArtifactWarning, g as StalenessSignal, h as StalenessReport, i as IntentArtifactSkill, l as ScanOptions, m as SkillStaleness, n as IntentArtifactFile, o as IntentConfig, p as SkillEntry, r as IntentArtifactSet, s as IntentPackage, t as IntentArtifactCoverageIgnore, u as ScanResult } from "./types-oEflMSso.mjs";
+import { i as runEditPackageJson, o as runSetupGithubActions, r as SetupGithubActionsResult, t as EditPackageJsonResult } from "./setup-DW3pn0QW.mjs";
 import { closeSync, existsSync, lstatSync, openSync, readFileSync, readSync, readdirSync, realpathSync } from "node:fs";
 
 //#region src/utils.d.ts
@@ -65,33 +65,6 @@ declare function collectStaleReviewItems(reports: Array<StalenessReport>): Array
 declare function createFailedStaleReviewItem(library: string): StaleReviewItem;
 declare function buildStaleReviewBody(items: Array<StaleReviewItem>): string;
 //#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: Array<string>;
-};
-declare function validateMetaPayload(payload: unknown): {
-  valid: boolean;
-  errors: Array<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/skill-use.d.ts
 interface SkillUse {
   packageName: string;
@@ -148,4 +121,4 @@ declare class ResolveSkillUseError extends Error {
 declare function isResolveSkillUseError(error: unknown): error is ResolveSkillUseError;
 declare function resolveSkillUse(use: string, scanResult: ScanResult): ResolveSkillResult;
 //#endregion
-export { type AgentName, type EditPackageJsonResult, type FeedbackPayload, type IntentArtifactCoverageIgnore, type IntentArtifactFile, type IntentArtifactSet, type IntentArtifactSkill, type IntentArtifactWarning, type IntentConfig, type IntentPackage, type IntentProjectConfig, type MetaFeedbackPayload, type MetaSkillName, type ResolveSkillResult, ResolveSkillUseError, type ResolveSkillUseErrorCode, type ScanOptions, type ScanResult, type SetupGithubActionsResult, type SkillEntry, type SkillStaleness, type SkillUse, SkillUseParseError, type SkillUseParseErrorCode, type StaleReviewItem, type StalenessReport, type StalenessSignal, buildStaleReviewBody, checkStaleness, collectStaleReviewItems, containsSecrets, createFailedStaleReviewItem, findSkillFiles, formatSkillUse, getDeps, hasGhCli, isResolveSkillUseError, isSkillUseParseError, metaToMarkdown, parseFrontmatter, parseSkillUse, readIntentArtifacts, resolveDepDir, resolveFrequency, resolveSkillUse, runEditPackageJson, runSetupGithubActions, scanForIntents, submitFeedback, submitMetaFeedback, toMarkdown, validateMetaPayload, validatePayload };
+export { type EditPackageJsonResult, type IntentArtifactCoverageIgnore, type IntentArtifactFile, type IntentArtifactSet, type IntentArtifactSkill, type IntentArtifactWarning, type IntentConfig, type IntentPackage, type ResolveSkillResult, ResolveSkillUseError, type ResolveSkillUseErrorCode, type ScanOptions, type ScanResult, type SetupGithubActionsResult, type SkillEntry, type SkillStaleness, type SkillUse, SkillUseParseError, type SkillUseParseErrorCode, type StaleReviewItem, type StalenessReport, type StalenessSignal, buildStaleReviewBody, checkStaleness, collectStaleReviewItems, createFailedStaleReviewItem, findSkillFiles, formatSkillUse, getDeps, isResolveSkillUseError, isSkillUseParseError, parseFrontmatter, parseSkillUse, readIntentArtifacts, resolveDepDir, resolveSkillUse, runEditPackageJson, runSetupGithubActions, scanForIntents };