hngr 0.3.0 → 0.5.0

package/dist/{skills-XDbBCC5f.mjs → skills-ZFmFyZtw.mjs}

@@ -1,5 +1,5 @@
-import { S as HngrError, g as resolveConnection, r as apiRequest, y as writeDirectoryAtomically } from "./http-2HWxLIOq.mjs";
-import { _ as resolveCapabilityVersion, a as failedResult, c as stringValues, d as homeDir, f as downloadContent, g as resolveCapability, h as parseCapabilityPath, i as errorBody, l as AGENTS, m as SKILL_KIND, n as readPublishFlags, o as positionalPaths, r as runPublish, s as runBatch, t as explicitName } from "./publish-EUqgdp0G.mjs";
+import { C as HngrError, b as writeDirectoryAtomically, g as resolveConnection, r as apiRequest } from "./http-DgHX7Fux.mjs";
+import { _ as resolveCapability, a as errorBody, c as runBatch, f as homeDir, g as parseCapabilityPath, h as SKILL_KIND, i as runPublish, l as stringValues, n as explicitName, o as failedResult, p as downloadContent, r as readPublishFlags, s as positionalPaths, t as resolveInstallScope, u as AGENTS, v as resolveCapabilityVersion } from "./scope-DVfDeQi2.mjs";
 import { lstat, mkdir, readFile, readdir, rename, rm, symlink, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -92,13 +92,6 @@ function downloadSkillPackage(connection, capabilityId, version, signal) {
 async function pathExists(path) {
 	return lstat(path).then(() => true, () => false);
 }
-function targetExistsError(path) {
-	return new HngrError({
-		type: "io",
-		title: `Target already exists: ${path}`,
-		detail: "Pass --force to replace it."
-	});
-}
 async function writeEntries(dest, entries) {
 	await mkdir(dest, { recursive: true });
 	for (const entry of entries) {
@@ -114,25 +107,22 @@ async function writeEntries(dest, entries) {
 }
 /**
 * Writes a skill through "temp directory → validate → rename": the target is
-* either absent or complete, never half-written. `--force` moves the old
-* directory aside before the rename so a failed swap puts it back.
+* either absent or complete, never half-written. Re-installing replaces the
+* previous directory, with the old one moved aside so a failed swap puts it
+* back.
 */
-async function installAtomically(dest, entries, force) {
-	await writeDirectoryAtomically(dest, (temp) => writeEntries(temp, entries), {
-		force,
-		existsError: () => targetExistsError(dest)
-	});
+async function installAtomically(dest, entries) {
+	await writeDirectoryAtomically(dest, (temp) => writeEntries(temp, entries));
 }
 /**
 * Creates a relative symlink to the canonical directory, falling back to a
 * copy when the platform refuses the link (Windows without Developer Mode).
 * Windows prefers a junction, which does not need elevated privileges; its
 * target must be absolute. A temp link plus rename replaces an existing link
-* atomically.
+* atomically; re-installing replaces an existing directory or link.
 */
-async function linkAtomically(canonical, target, entries, force, options = {}) {
+async function linkAtomically(canonical, target, entries, options = {}) {
 	const exists = await pathExists(target);
-	if (exists && !force) throw targetExistsError(target);
 	await mkdir(dirname(target), { recursive: true });
 	const temp = resolve(dirname(target), `.hngr-${basename(target)}-${randomUUID()}.link`);
 	const windows = (options.platform ?? process.platform) === "win32";
@@ -150,7 +140,7 @@ async function linkAtomically(canonical, target, entries, force, options = {}) {
 		return { mode: "symlink" };
 	} catch {
 		await rm(temp, { force: true }).catch(() => {});
-		await installAtomically(target, entries, false);
+		await installAtomically(target, entries);
 		return {
 			mode: "copy",
 			warning: `warning: could not create a link at ${target}; copied instead`
@@ -158,8 +148,8 @@ async function linkAtomically(canonical, target, entries, force, options = {}) {
 	}
 }
 /** Copies one target directory atomically, without a canonical store. */
-async function copyAtomically(target, entries, force) {
-	await installAtomically(target, entries, force);
+async function copyAtomically(target, entries) {
+	await installAtomically(target, entries);
 }
 // src/skills/resolve.ts
 /** Parses `<name>` or `<namespace>/<name>`, with an optional `@YYYY.MM.DD.N`. */
@@ -562,17 +552,19 @@ function failureResult(parsed, err, version) {
 		canonicalPath: null
 	};
 }
-/** Prompts need both stdin and stdout on a TTY plus a prompter that can multi-select. */
+/** Agent prompts need a TTY on both ends, a multi-select prompter, and human output mode. */
 function canPrompt(ctx) {
-	return ctx.io.stdin.isTTY && ctx.io.stdout.isTTY && ctx.io.prompts?.multiselect !== void 0;
+	return !ctx.flags.json && ctx.io.stdin.isTTY && ctx.io.stdout.isTTY && ctx.io.prompts?.multiselect !== void 0;
 }
 function noAgentSelectionError(examplePath, global) {
 	return usage("No agent target selected", `Pass --agent <id> (repeatable) or --all. For example: hngr skills add ${examplePath} --agent claude-code${global ? " --global" : ""}`);
 }
+const ALL_AGENTS = "__all__";
 /**
-* One multi-select for every Agent Target, pre-selecting those whose skills
-* directory is detected. Detection is only a pre-selection hint; a non-TTY
-* invocation never consults the filesystem and must pass --agent or --all.
+* One multi-select for the agents that keep their own skills directory.
+* `.agents` is always installed, so universal agents never appear here.
+* Detection only preselects; a non-TTY invocation never consults the
+* filesystem and must pass --agent or --all.
 */
 async function selectAgents(ctx, argv, examplePath, global) {
 	const requested = stringValues(argv.agent);
@@ -582,26 +574,28 @@ async function selectAgents(ctx, argv, examplePath, global) {
 		return AGENT_TARGETS.filter((agent) => requested.includes(agent.id));
 	}
 	if (argv.all === true) return [...AGENT_TARGETS];
-	if (canPrompt(ctx)) {
-		const multiselect = ctx.io.prompts?.multiselect;
-		if (!multiselect) throw noAgentSelectionError(examplePath, global);
-		const cwd = process.cwd();
-		const choices = [];
-		for (const agent of AGENT_TARGETS) {
-			const dir = targetSkillsDir(agent, cwd, ctx.env, global);
-			choices.push({
-				option: {
-					value: agent.id,
-					label: `${agent.id}  ${displayPath(dir, cwd)}`
-				},
-				detected: await pathExists(dirname(dir))
-			});
-		}
-		const selected = await multiselect("Select agent targets", choices.map((choice) => choice.option), choices.filter((choice) => choice.detected).map((choice) => choice.option.value));
-		if (selected.length === 0) throw noAgentSelectionError(examplePath, global);
-		return AGENT_TARGETS.filter((agent) => selected.includes(agent.id));
+	const multiselect = ctx.io.prompts?.multiselect;
+	if (!canPrompt(ctx) || !multiselect) throw noAgentSelectionError(examplePath, global);
+	const cwd = process.cwd();
+	const linkAgents = AGENT_TARGETS.filter((agent) => agent.link);
+	const options = [{
+		value: ALL_AGENTS,
+		label: "All agents",
+		hint: "select every agent below"
+	}];
+	const initialValues = [];
+	for (const agent of linkAgents) {
+		const dir = targetSkillsDir(agent, cwd, ctx.env, global);
+		options.push({
+			value: agent.id,
+			label: agent.id,
+			hint: displayPath(dir, cwd)
+		});
+		if (await pathExists(dirname(dir))) initialValues.push(agent.id);
 	}
-	throw noAgentSelectionError(examplePath, global);
+	const selected = await multiselect("Install for another agent", options, initialValues, ".agents/skills is always installed; press Enter to skip");
+	const chosen = selected.includes(ALL_AGENTS) ? new Set(linkAgents.map((agent) => agent.id)) : new Set(selected);
+	return linkAgents.filter((agent) => chosen.has(agent.id));
 }
 function frontmatterName(manifest) {
 	const text = manifest.toString("utf8");
@@ -657,16 +651,12 @@ function planInstall(cwd, env, destName, agents, options) {
 async function install(ctx, plan, entries) {
 	const cwd = process.cwd();
 	const display = (path) => displayPath(path, cwd);
-	const destinations = [plan.canonical, ...plan.targets.map((target) => target.path)].filter((path) => path !== null);
-	if (!ctx.flags.force) {
-		for (const path of destinations) if (await pathExists(path)) throw targetExistsError(display(path));
-	}
-	if (plan.canonical) await installAtomically(plan.canonical, entries, ctx.flags.force);
+	if (plan.canonical) await installAtomically(plan.canonical, entries);
 	const installed = [];
 	let failure = null;
 	for (const target of plan.targets) try {
 		if (target.mode === "copy" || !plan.canonical) {
-			await copyAtomically(target.path, entries, ctx.flags.force);
+			await copyAtomically(target.path, entries);
 			installed.push({
 				agent: target.agent,
 				path: display(target.path),
@@ -675,7 +665,7 @@ async function install(ctx, plan, entries) {
 			});
 			continue;
 		}
-		const result = await linkAtomically(plan.canonical, target.path, entries, ctx.flags.force);
+		const result = await linkAtomically(plan.canonical, target.path, entries);
 		if (result.warning) ctx.summary(result.warning);
 		installed.push({
 			agent: target.agent,
@@ -697,6 +687,26 @@ async function install(ctx, plan, entries) {
 		failure
 	};
 }
+function withDot(path) {
+	return path.startsWith("/") ? path : `./${path}`;
+}
+/** The boxed result shown after an interactive install. */
+function installSummary(outcome, canonicalPath) {
+	const lines = [];
+	const installed = outcome.targets.filter((target) => target.status === "installed");
+	if (canonicalPath) {
+		lines.push(`✓ ${withDot(canonicalPath)}`);
+		const universal = AGENT_TARGETS.filter((agent) => !agent.link).map((agent) => agent.id);
+		if (universal.length > 0) lines.push(`  universal: ${universal.join(", ")}`);
+	} else for (const target of installed) lines.push(`✓ ${withDot(target.path)}`);
+	const symlinked = installed.filter((target) => target.mode === "symlink" && target.agent).map((target) => target.agent);
+	const copied = installed.filter((target) => target.mode === "copy" && target.agent).map((target) => target.agent);
+	if (symlinked.length > 0) lines.push(`  symlinked: ${symlinked.join(", ")}`);
+	if (copied.length > 0) lines.push(`  copied: ${copied.join(", ")}`);
+	const failed = outcome.targets.filter((target) => target.status === "failed");
+	if (failed.length > 0) lines.push(`  failed: ${failed.map((target) => target.path).join(", ")}`);
+	return lines.join("\n");
+}
 async function addOne(ctx, connection, parsed, destName, agents, dir, global, copy, state) {
 	const capability = await resolveSkill(connection, parsed);
 	const version = resolveVersion(capability, parsed);
@@ -708,10 +718,9 @@ async function addOne(ctx, connection, parsed, destName, agents, dir, global, co
 	});
 	const canonicalPath = plan.canonical ? displayPath(plan.canonical, process.cwd()) : null;
 	if (ctx.flags.dryRun) {
-		if (!ctx.flags.force) {
-			for (const path of [plan.canonical, ...plan.targets.map((target) => target.path)]) if (path && await pathExists(path)) throw targetExistsError(displayPath(path, process.cwd()));
-		}
-		ctx.summary(`resolved ${parsed.namespace}/${parsed.name} to version ${version}`);
+		ctx.detail(`dry-run: would install ${parsed.namespace}/${parsed.name}@${version}`);
+		if (canonicalPath) ctx.detail(`  ${canonicalPath}`);
+		for (const target of plan.targets) ctx.detail(`  ${displayPath(target.path, process.cwd())} (${target.mode})`);
 		return { result: {
 			name: capability.name,
 			namespace: capability.namespace,
@@ -727,19 +736,18 @@ async function addOne(ctx, connection, parsed, destName, agents, dir, global, co
 			error: null
 		} };
 	}
-	const download = await downloadSkillPackage(connection, capability.id, version);
-	const pkg = readSkillPackage(download.bytes);
-	ctx.summary(`resolved ${parsed.namespace}/${parsed.name} to version ${version}`);
+	const pkg = readSkillPackage((await downloadSkillPackage(connection, capability.id, version)).bytes);
 	const declaredName = frontmatterName(pkg.manifest);
 	if (declaredName !== void 0 && declaredName !== destName) ctx.summary(`warning: SKILL.md declares name ${JSON.stringify(declaredName)} but the directory is ${JSON.stringify(destName)}`);
 	const outcome = await install(ctx, plan, pkg.entries);
-	const universal = agents.filter((agent) => !agent.link).map((agent) => agent.id);
-	const etag = download.etag ? ` (ETag ${download.etag})` : "";
-	const verb = outcome.failure ? "partially installed" : "installed";
-	ctx.progress(`${verb} ${capability.namespace}/${capability.name}@${version}${etag}`);
-	if (canonicalPath) ctx.progress(`  canonical ${canonicalPath}`);
-	if (universal.length > 0) ctx.progress(`  universal: ${universal.join(", ")}`);
-	for (const target of outcome.targets) ctx.progress(target.status === "failed" ? `  failed ${target.path}` : `  ${target.mode} ${target.path}`);
+	const verb = outcome.failure ? "Partially installed" : "Installed";
+	const note = ctx.io.prompts?.note;
+	if (!ctx.flags.json && !ctx.flags.quiet && ctx.io.stderr.isTTY && note) note(installSummary(outcome, canonicalPath), `${verb} ${capability.namespace}/${capability.name}@${version}`);
+	else {
+		ctx.progress(`${verb.toLowerCase()} ${capability.namespace}/${capability.name}@${version}`);
+		if (canonicalPath) ctx.progress(`  ${canonicalPath}`);
+		for (const target of outcome.targets) ctx.progress(target.status === "failed" ? `  failed ${target.path}` : `  ${target.path} (${target.mode})`);
+	}
 	return { result: {
 		name: capability.name,
 		namespace: capability.namespace,
@@ -849,12 +857,13 @@ async function add(ctx, argv) {
 	const dir = stringFlag(argv, "dir");
 	const as = stringFlag(argv, "as");
 	if (as !== void 0 && (as.includes("/") || as.includes("\\") || as === "." || as === "..")) throw usage(`Invalid --as name ${JSON.stringify(as)}`, "Pass a single directory name.");
-	const global = argv.global === true;
+	const requestedGlobal = argv.global === true;
 	const copy = argv.copy === true;
-	if (dir !== void 0 && global) throw usage("--dir cannot be combined with --global");
+	if (dir !== void 0 && requestedGlobal) throw usage("--dir cannot be combined with --global");
 	if (dir !== void 0 && (stringValues(argv.agent).length > 0 || argv.all === true)) throw usage("--dir cannot be combined with --agent or --all");
 	if (as !== void 0) assertNotReserved(as);
 	for (const parsed of parsedPaths) assertNotReserved(as ?? parsed.name);
+	const global = dir === void 0 ? await resolveInstallScope(ctx, requestedGlobal) === "global" : false;
 	const agents = dir === void 0 ? await selectAgents(ctx, argv, rawPaths[0] ?? "", global) : [];
 	const connection = await resolveConnection(ctx.flags, ctx.env);
 	const { results, failed } = await runBatch({
@@ -865,7 +874,8 @@ async function add(ctx, argv) {
 		},
 		failure: failureResult
 	});
-	ctx.writePayload({ results });
+	if (ctx.flags.json || !ctx.io.stdout.isTTY) ctx.writePayload({ results });
+	if (!ctx.flags.json && !ctx.flags.dryRun && !ctx.flags.quiet && !failed && ctx.io.stderr.isTTY) ctx.io.prompts?.outro?.("Done! Review skills before use; they run with full agent permissions.");
 	return failed ? 1 : 0;
 }
 export { add, publish };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hngr",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "The Hangar CLI: install skills and MCP servers into coding agents, and drive the Management API.",
   "keywords": [
     "hangar",