@tryaura/aura-cli 0.1.0 → 0.2.0

package/dist/{skill-deployment-plan-C4GTrVSy.js → shared-link-plan-DVgOyqP9.js}

@@ -3,7 +3,28 @@ import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { Buffer, isUtf8 } from "node:buffer";
 import { createHash } from "node:crypto";
 import { createTwoFilesPatch } from "diff";
+import { gt, valid } from "semver";
 import { isDeepStrictEqual } from "node:util";
+//#region ../core/src/display-path.ts
+/**
+* Names a path the way a user can address it from where they ran the command.
+*
+* Project-relative first, then `~/`, then the path unchanged. Every renderer goes through this so
+* one report cannot show the same file two ways — a check that bakes a path into its message and
+* the CLI that prints that finding's locations must agree, or the two lines read as two files.
+*/
+function displayPath(path, roots) {
+	const project = pathInside(roots.projectRoot ?? roots.cwd, path);
+	if (project !== void 0) return project;
+	const home = pathInside(roots.homeDir, path);
+	return home === void 0 ? path : `~/${home}`;
+}
+function pathInside(root, path) {
+	const difference = relative(root, path);
+	if (difference.length === 0 || difference === ".." || difference.startsWith(`..${sep}`) || isAbsolute(difference)) return;
+	return difference.split(sep).join("/");
+}
+//#endregion
 //#region ../core/src/pluralize.ts
 /** Selects the noun or verb form that agrees with a numeric count. */
 function pluralize(count, singular, plural = `${singular}s`) {
@@ -51,6 +72,7 @@ var src_default = definePlugin({
 		id: "directory:agenticskills",
 		kind: "directory",
 		name: "agenticskills.io",
+		protocol: "agenticskills",
 		url: "https://agenticskills.io"
 	}],
 	snippets: [
@@ -161,6 +183,7 @@ function isRecord(value) {
 }
 //#endregion
 //#region ../core/src/manifest/schema-values.ts
+const SHA256_PATTERN = /^[0-9a-f]{64}$/u;
 var AuraManifestValidationError = class extends Error {
 	jsonPath;
 	constructor(jsonPath, message) {
@@ -330,11 +353,44 @@ function targetApps(value, path, name, scope, claimed) {
 	}
 	return entries;
 }
+const MAX_TRUSTED_PATH_LENGTH = 1024;
+/**
+* Reads `trustedRepoPresets`, the repository presets the user accepted during setup.
+*
+* Each entry binds an absolute preset path to a hash of the exact contents that were reviewed, so
+* a file edited after acceptance is untrusted again until someone looks at the new contents. Only
+* acceptances appear here: declining records nothing, and the next interactive setup asks again.
+*/
+function optionalTrustedRepoPresets(value) {
+	if (value === void 0) return {};
+	if (!Array.isArray(value)) throw invalid("$.trustedRepoPresets", "must be an array");
+	if (value.length > 64) throw invalid("$.trustedRepoPresets", `must contain at most ${String(64)} entries`);
+	const paths = /* @__PURE__ */ new Set();
+	return { trustedRepoPresets: Object.freeze(value.map((candidate, index) => {
+		const path = `$.trustedRepoPresets[${String(index)}]`;
+		const entry = requiredObject(candidate, path);
+		const presetPath = requiredString(entry, "path", path);
+		if (presetPath.length === 0 || presetPath.length > MAX_TRUSTED_PATH_LENGTH) throw invalid(`${path}.path`, `must be a non-empty path of at most ${String(MAX_TRUSTED_PATH_LENGTH)} characters`);
+		if (paths.has(presetPath)) throw invalid(`${path}.path`, "must not duplicate another trusted preset path");
+		paths.add(presetPath);
+		const hash = requiredString(entry, "hash", path);
+		if (!SHA256_PATTERN.test(hash)) throw invalid(`${path}.hash`, "must be a lowercase SHA-256 hash");
+		return Object.freeze({
+			...entry,
+			hash,
+			path: presetPath
+		});
+	})) };
+}
 //#endregion
 //#region ../core/src/manifest/schema.ts
-const SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+const APP_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/u;
+const MCP_CATALOG_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*\/[a-zA-Z0-9][a-zA-Z0-9._-]*$/u;
 const SKILL_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const SKILL_SOURCE_PATTERN = /^(?:directory|driver|plugin):[^\s:]+$/u;
+const OVERRIDE_KEY_PATTERN = /^[a-z][a-zA-Z0-9]{0,63}$/u;
+/** Room for several future override kinds without leaving the forward-compat window unbounded. */
+const MAX_OVERRIDE_KEYS = 32;
 /**
 * How deep the manifest may nest.
 *
@@ -354,14 +410,50 @@ function validateAuraManifest(value) {
 		...source,
 		apps: apps(source["apps"]),
 		...optionalChecks(source["checks"]),
+		...optionalIdList(source["ignoredApps"], "$.ignoredApps", APP_ID_PATTERN, "ignoredApps"),
 		mcpServers: mcpServers(source["mcpServers"]),
 		ownership: ownership(source["ownership"]),
+		...optionalOverrides(source["overrides"]),
 		...optionalPreset(source["preset"]),
 		schemaVersion: 1,
 		skills: skills(source["skills"]),
-		snippets: snippets(source["snippets"])
+		snippets: snippets(source["snippets"]),
+		...optionalTrustedRepoPresets(source["trustedRepoPresets"])
 	});
 }
+/**
+* Reads `overrides`, keeping the extension keys a newer Aura may have written.
+*
+* Passing unknown keys through matches how the top-level object is normalized, so a downgrade does
+* not quietly delete a newer build's decisions. Unlike the top level, though, this object is
+* rebuilt from scratch on every setup run, so an unbounded bag here would be rewritten verbatim
+* forever: the key count and spelling are bounded to keep the forward-compatibility window from
+* doubling as unbounded manifest storage.
+*/
+function optionalOverrides(value) {
+	if (value === void 0) return {};
+	const source = requiredObject(value, "$.overrides");
+	const keys = Object.keys(source);
+	if (keys.length > MAX_OVERRIDE_KEYS) throw invalid("$.overrides", `must contain at most ${String(MAX_OVERRIDE_KEYS)} keys`);
+	for (const key of keys) if (!OVERRIDE_KEY_PATTERN.test(key)) throw invalid(`$.overrides.${key}`, "must be a camelCase override name");
+	const required = optionalIdList(source["requiredMcpServers"], "$.overrides.requiredMcpServers", MCP_CATALOG_ID_PATTERN, "requiredMcpServers");
+	return { overrides: Object.freeze({
+		...source,
+		...required
+	}) };
+}
+function optionalIdList(value, path, pattern, key) {
+	if (value === void 0) return {};
+	const ids = stringArray(value, path);
+	if (ids.length > 256) throw invalid(path, "must contain at most 256 ids");
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, id] of ids.entries()) {
+		if (!pattern.test(id)) throw invalid(`${path}[${String(index)}]`, "must be a valid id");
+		if (seen.has(id)) throw invalid(`${path}[${String(index)}]`, "must not duplicate another id");
+		seen.add(id);
+	}
+	return { [key]: ids };
+}
 function skills(value) {
 	if (!Array.isArray(value)) throw invalid("$.skills", "must be an array");
 	const ids = /* @__PURE__ */ new Set();
@@ -1106,6 +1198,59 @@ function stripManagedMarkers(source) {
 	return kept.join("");
 }
 //#endregion
+//#region ../core/src/managed-block/reconcile-snippet.ts
+/** Reconciles exactly one snippet while preserving every other source byte. */
+function reconcileManagedSnippet(source, snippetId, resolution) {
+	const current = readManagedBlock(source);
+	if (current.status === "invalid") return invalidResult$1(source, current.notes, current.problems);
+	if (current.status === "absent") return missingSnippet(source, current.notes, snippetId, "an Aura-managed block");
+	const snippet = current.block.snippets.find((candidate) => candidate.id === snippetId);
+	if (snippet === void 0) return missingSnippet(source, current.notes, snippetId, "the Aura-managed block");
+	const lineEnding = markerLineEnding(source, snippet.startOffset, snippet.contentStartOffset);
+	const canonical = resolution.kind === "restore" ? canonicalizeManagedSnippet(resolution.content) : void 0;
+	if (canonical !== void 0) {
+		const problems = managedSnippetContentProblems(snippet.id, canonical);
+		if (problems.length > 0) return invalidResult$1(source, current.notes, problems);
+	}
+	const content = canonical === void 0 ? snippet.content : withLineEnding(canonical, lineEnding);
+	const hash = canonical === void 0 ? snippet.computedHash : hashCanonicalManagedSnippet(canonical);
+	const opening = `${AURA_MANAGED_SNIPPET_BEGIN_PREFIX}${snippet.id} sha256=${hash} -->${lineEnding}`;
+	const updated = source.slice(0, snippet.startOffset) + opening + content + source.slice(snippet.contentEndOffset);
+	return updated === source ? Object.freeze({
+		content: source,
+		notes: current.notes,
+		status: "unchanged"
+	}) : Object.freeze({
+		content: updated,
+		notes: current.notes,
+		status: "updated"
+	});
+}
+/** Creates the opt-in edited-versus-canonical detail used by the merge choice. */
+function diffManagedSnippet(path, editedContent, canonicalContent) {
+	return createTwoFilesPatch(`${path} (edited)`, `${path} (canonical)`, canonicalizeManagedSnippet(editedContent), canonicalizeManagedSnippet(canonicalContent), "edited", "canonical", { context: 3 });
+}
+function missingSnippet(source, notes, snippetId, location) {
+	return invalidResult$1(source, notes, [Object.freeze({
+		code: "missing-snippet",
+		message: `Snippet "${snippetId}" does not exist in ${location}.`
+	})]);
+}
+function invalidResult$1(source, notes, problems) {
+	return Object.freeze({
+		content: source,
+		notes,
+		problems,
+		status: "invalid"
+	});
+}
+function markerLineEnding(source, startOffset, contentStartOffset) {
+	return source.slice(startOffset, contentStartOffset).endsWith("\r\n") ? "\r\n" : "\n";
+}
+function withLineEnding(content, lineEnding) {
+	return lineEnding === "\n" ? content : content.replaceAll("\n", lineEnding);
+}
+//#endregion
 //#region ../core/src/managed-block/reconcile-desired.ts
 function prepareDesiredSnippets(snippets, options) {
 	const ids = /* @__PURE__ */ new Set();
@@ -1307,6 +1452,134 @@ function settle(source, content, notes) {
 	});
 }
 //#endregion
+//#region ../core/src/managed-content/revision.ts
+/** Whether a source revision is a reviewable update, a divergence, or already installed. */
+function managedContentRevisionStatus(installedVersion, installedHash, availableVersion, availableHash) {
+	if (installedVersion === availableVersion) return installedHash === availableHash ? "current" : "update";
+	if (valid(installedVersion) === null || valid(availableVersion) === null) return "diverged";
+	return gt(availableVersion, installedVersion) ? "update" : "diverged";
+}
+/** Replaces one shared skill tree using the same operation ordering in setup and guided checks. */
+function planSharedSkillTreeUpdate(root, existingEntries, desired) {
+	const desiredPaths = new Set(desired.files.map((file) => resolve(root, ...file.path.split("/"))));
+	const desiredParents = ancestorDirectories(desiredPaths);
+	return [...[...existingEntries.filter((entry) => {
+		const path = resolve(entry.path);
+		return !desiredPaths.has(path) && (entry.kind !== "directory" || !desiredParents.has(path));
+	})].sort((left, right) => right.path.length - left.path.length).map((entry) => ({
+		path: entry.path,
+		type: "remove"
+	})), ...desired.files.map((file) => ({
+		content: file.content,
+		path: join(root, ...file.path.split("/")),
+		type: "write"
+	}))];
+}
+/**
+* Every directory that contains at least one desired path.
+*
+* Precomputed once so the stale filter stays linear: comparing each existing directory against
+* every desired path pairwise re-normalized both sides on every comparison.
+*/
+function ancestorDirectories(paths) {
+	const parents = /* @__PURE__ */ new Set();
+	for (const path of paths) {
+		let parent = dirname(path);
+		while (!parents.has(parent)) {
+			parents.add(parent);
+			const next = dirname(parent);
+			if (next === parent) break;
+			parent = next;
+		}
+	}
+	return parents;
+}
+//#endregion
+//#region ../core/src/workspace/skill-deployment-plan.ts
+/** Plans one manifest skill's link into one adapter-declared directory. */
+function planSkillDeployment(app, model, skillId, directoryId, options = {}) {
+	const directory = app.skillDirectories?.find((candidate) => candidate.id === directoryId);
+	if (directory === void 0) return {
+		kind: "blocked",
+		path: skillId,
+		reason: "The application no longer declares this skills directory."
+	};
+	const path = join(directory.path, skillId);
+	const target = join(sharedSkillsRoot(model.homeDir), skillId);
+	if (!(model.sharedSkills?.some((skill) => skill.id === skillId) === true) && options.assumeShared !== true) return {
+		kind: "blocked",
+		path,
+		reason: `The shared copy at ${target} is missing. Reinstall skill "${skillId}" before deploying it.`
+	};
+	const status = skillDeploymentStatus(app, directory, skillId);
+	if (status === void 0 || !status.exists) return {
+		kind: "planned",
+		path,
+		plan: symlinkPlan(app, path, target)
+	};
+	if (status.problem !== void 0) return {
+		kind: "blocked",
+		path,
+		reason: `Aura could not safely inspect ${path} (${status.problem}) and will not replace it.`
+	};
+	if (status.pathKind !== "symlink" || status.symlinkTarget === void 0) return {
+		kind: "blocked",
+		path,
+		reason: `${path} is not an Aura-managed skill link. Move it aside before deploying skill "${skillId}" there.`
+	};
+	const actualTarget = absoluteTarget(path, status.symlinkTarget);
+	if (actualTarget === resolve(target)) return {
+		kind: "planned",
+		path,
+		plan: convergedPlan$1(app, skillId)
+	};
+	if (!isAuraOwnedSkillTarget(model.homeDir, actualTarget)) return {
+		kind: "blocked",
+		path,
+		reason: `${path} is not an Aura-managed skill link because it points outside Aura's shared skills directory. It was preserved.`
+	};
+	return {
+		kind: "planned",
+		path,
+		plan: symlinkPlan(app, path, target)
+	};
+}
+/** Finds the captured status for one deployed skill path. */
+function skillDeploymentStatus(app, directory, skillId) {
+	const path = resolve(join(directory.path, skillId));
+	return app.sourceFiles.find((file) => resolve(file.spec.path) === path);
+}
+/** Whether a lexical target lies within Aura's canonical shared skills root. */
+function isAuraOwnedSkillTarget(homeDir, targetPath) {
+	const root = resolve(sharedSkillsRoot(homeDir));
+	const target = resolve(targetPath);
+	const fromRoot = relative(root, target);
+	return fromRoot !== "" && fromRoot !== ".." && !fromRoot.startsWith(`..${sep}`);
+}
+/** Canonical location Aura uses for shared skill trees. */
+function sharedSkillsRoot(homeDir) {
+	return join(homeDir, "agents", "skills");
+}
+function absoluteTarget(path, target) {
+	return isAbsolute(target) ? resolve(target) : resolve(dirname(path), target);
+}
+function symlinkPlan(app, path, target) {
+	return {
+		operations: [{
+			path,
+			target,
+			type: "symlink"
+		}],
+		summary: `Deploy the shared skill to ${app.displayName}.`
+	};
+}
+function convergedPlan$1(app, skillId) {
+	return {
+		operations: [],
+		summary: `${app.displayName} already loads shared skill "${skillId}".`
+	};
+}
+//#endregion
 //#region ../core/src/workspace/mcp-classify.ts
 /**
 * Splits desired servers into the ones Aura may write and the collisions a person has to settle.
@@ -1823,7 +2096,7 @@ function planImportLine(app, model, link, status, sourceContent) {
 		id: SHARED_LINK_SNIPPET_ID
 	}]);
 	if (reconciled.status === "invalid") return { blocked: `The Aura-managed block in ${link.entryPath} is malformed, so Aura will not rewrite the file. Repair or delete the block and run check --fix again.` };
-	if (reconciled.status === "unchanged" && observedStateHolds(sourceContent)) return { plan: convergedPlan$1(app) };
+	if (reconciled.status === "unchanged" && observedStateHolds(sourceContent)) return { plan: convergedPlan(app) };
 	return { plan: writePlan(app, link, reconciled.content, model.homeDir) };
 }
 /**
@@ -1847,7 +2120,7 @@ function planNativeCopy(app, model, link, status, sourceContent) {
 	const content = sourceContent ?? instructionEntry(app, link.entryPath)?.content;
 	const refusal = nativeCopyRefusal(status, sourceContent, content, link.content);
 	if (refusal !== void 0) return { blocked: refusal };
-	if (status?.exists === true && content === link.content && observedStateHolds(sourceContent)) return { plan: convergedPlan$1(app) };
+	if (status?.exists === true && content === link.content && observedStateHolds(sourceContent)) return { plan: convergedPlan(app) };
 	return { plan: writePlan(app, link, link.content ?? "", model.homeDir) };
 }
 function nativeCopyRefusal(status, sourceContent, content, desired) {
@@ -1856,7 +2129,7 @@ function nativeCopyRefusal(status, sourceContent, content, desired) {
 function planSymlink(app, model, link, status, options) {
 	if (status?.exists === true && status.pathKind !== "symlink" && options.sourceContent === void 0) return { blocked: "The existing file is user-owned. Consolidate its content before replacing it with a symlink." };
 	const target = options.symlinkTarget ?? model.sharedInstructions.path;
-	if (observedStateHolds(options.sourceContent) && pointsAt(status, target)) return { plan: convergedPlan$1(app) };
+	if (observedStateHolds(options.sourceContent) && pointsAt(status, target)) return { plan: convergedPlan(app) };
 	return { plan: {
 		operations: [{
 			path: link.entryPath,
@@ -1878,7 +2151,7 @@ function pointsAt(status, target) {
 	return resolve(status.symlinkTarget) === resolve(target);
 }
 /** No work: the entry already loads the shared source, so the summary says so rather than promising a link. */
-function convergedPlan$1(app) {
+function convergedPlan(app) {
 	return {
 		operations: [],
 		summary: `${app.displayName} already loads the shared instruction source.`
@@ -1908,89 +2181,4 @@ function entryStatus(app, path) {
 	return app.sourceFiles.find((file) => resolve(file.spec.path) === resolve(path));
 }
 //#endregion
-//#region ../core/src/workspace/skill-deployment-plan.ts
-/** Plans one manifest skill's link into one adapter-declared directory. */
-function planSkillDeployment(app, model, skillId, directoryId, options = {}) {
-	const directory = app.skillDirectories?.find((candidate) => candidate.id === directoryId);
-	if (directory === void 0) return {
-		kind: "blocked",
-		path: skillId,
-		reason: "The application no longer declares this skills directory."
-	};
-	const path = join(directory.path, skillId);
-	const target = join(sharedSkillsRoot(model.homeDir), skillId);
-	if (!(model.sharedSkills?.some((skill) => skill.id === skillId) === true) && options.assumeShared !== true) return {
-		kind: "blocked",
-		path,
-		reason: `The shared copy at ${target} is missing. Reinstall skill "${skillId}" before deploying it.`
-	};
-	const status = skillDeploymentStatus(app, directory, skillId);
-	if (status === void 0 || !status.exists) return {
-		kind: "planned",
-		path,
-		plan: symlinkPlan(app, path, target)
-	};
-	if (status.problem !== void 0) return {
-		kind: "blocked",
-		path,
-		reason: `Aura could not safely inspect ${path} (${status.problem}) and will not replace it.`
-	};
-	if (status.pathKind !== "symlink" || status.symlinkTarget === void 0) return {
-		kind: "blocked",
-		path,
-		reason: `${path} is not an Aura-managed skill link. Move it aside before deploying skill "${skillId}" there.`
-	};
-	const actualTarget = absoluteTarget(path, status.symlinkTarget);
-	if (actualTarget === resolve(target)) return {
-		kind: "planned",
-		path,
-		plan: convergedPlan(app, skillId)
-	};
-	if (!isAuraOwnedSkillTarget(model.homeDir, actualTarget)) return {
-		kind: "blocked",
-		path,
-		reason: `${path} is not an Aura-managed skill link because it points outside Aura's shared skills directory. It was preserved.`
-	};
-	return {
-		kind: "planned",
-		path,
-		plan: symlinkPlan(app, path, target)
-	};
-}
-/** Finds the captured status for one deployed skill path. */
-function skillDeploymentStatus(app, directory, skillId) {
-	const path = resolve(join(directory.path, skillId));
-	return app.sourceFiles.find((file) => resolve(file.spec.path) === path);
-}
-/** Whether a lexical target lies within Aura's canonical shared skills root. */
-function isAuraOwnedSkillTarget(homeDir, targetPath) {
-	const root = resolve(sharedSkillsRoot(homeDir));
-	const target = resolve(targetPath);
-	const fromRoot = relative(root, target);
-	return fromRoot !== "" && fromRoot !== ".." && !fromRoot.startsWith(`..${sep}`);
-}
-/** Canonical location Aura uses for shared skill trees. */
-function sharedSkillsRoot(homeDir) {
-	return join(homeDir, "agents", "skills");
-}
-function absoluteTarget(path, target) {
-	return isAbsolute(target) ? resolve(target) : resolve(dirname(path), target);
-}
-function symlinkPlan(app, path, target) {
-	return {
-		operations: [{
-			path,
-			target,
-			type: "symlink"
-		}],
-		summary: `Deploy the shared skill to ${app.displayName}.`
-	};
-}
-function convergedPlan(app, skillId) {
-	return {
-		operations: [],
-		summary: `${app.displayName} already loads shared skill "${skillId}".`
-	};
-}
-//#endregion
-export { MAX_MUTABLE_FILE_BYTES as A, AuraManifestError as B, renderRedactedWriteDiff as C, renderRemoveDiff as D, renderMoveDiff as E, parseAuraManifest as F, src_default as H, errorCode as I, errorMessage as L, assertAuraManifestWritable as M, createAuraManifestWriteOperation as N, renderSymlinkDiff as O, createEmptyAuraManifest as P, isRecord as R, hashManagedSnippet as S, renderConflict as T, pluralize as U, SHARED_INSTRUCTIONS_TEMPLATE as V, managedSnippetContentProblems as _, planSharedInstructionLink as a, canonicalizeManagedSnippet as b, planMcpSecretRemediation as c, planDesiredMcpConvergence as d, planManifestMcpConvergence as f, reconcileParsedManagedBlock as g, createAppMcpConvergence as h, skillDeploymentStatus as i, MAX_RETAINED_PLAN_BYTES as j, FILE_MODES as k, rememberMcpSecretPlanner as l, rememberMcpConvergence as m, planSkillDeployment as n, canPlanMcpSecretRemediation as o, planMcpServerRemoval as p, sharedSkillsRoot as r, createAppMcpSecretPlanner as s, isAuraOwnedSkillTarget as t, mcpConvergenceBlockers as u, readManagedBlock as v, renderArchiveDiff as w, hashCanonicalManagedSnippet as x, AURA_MANAGED_SNIPPET_BEGIN_PREFIX as y, resolveAuraManifestPath as z };
+export { renderRemoveDiff as A, errorMessage as B, canonicalizeManagedSnippet as C, renderArchiveDiff as D, renderRedactedWriteDiff as E, assertAuraManifestWritable as F, src_default as G, resolveAuraManifestPath as H, createAuraManifestWriteOperation as I, pluralize as K, createEmptyAuraManifest as L, FILE_MODES as M, MAX_MUTABLE_FILE_BYTES as N, renderConflict as O, MAX_RETAINED_PLAN_BYTES as P, parseAuraManifest as R, readManagedBlock as S, hashManagedSnippet as T, AuraManifestError as U, isRecord as V, SHARED_INSTRUCTIONS_TEMPLATE as W, planSharedSkillTreeUpdate as _, rememberMcpSecretPlanner as a, reconcileManagedSnippet as b, planManifestMcpConvergence as c, createAppMcpConvergence as d, isAuraOwnedSkillTarget as f, managedContentRevisionStatus as g, skillDeploymentStatus as h, planMcpSecretRemediation as i, renderSymlinkDiff as j, renderMoveDiff as k, planMcpServerRemoval as l, sharedSkillsRoot as m, canPlanMcpSecretRemediation as n, mcpConvergenceBlockers as o, planSkillDeployment as p, displayPath as q, createAppMcpSecretPlanner as r, planDesiredMcpConvergence as s, planSharedInstructionLink as t, rememberMcpConvergence as u, reconcileParsedManagedBlock as v, hashCanonicalManagedSnippet as w, managedSnippetContentProblems as x, diffManagedSnippet as y, errorCode as z };

package/dist/{types-DmBu6g0d.d.ts → types--E7zqKfw.d.ts}

@@ -57,8 +57,10 @@ interface CliRuntime {
   /**
    * Color depth reported to the command framework.
    *
-   * Defaults to what the terminal supports, honouring `NO_COLOR` and `FORCE_COLOR`. Always no color
-   * when `stdout` is injected, since the destination is then not a terminal Aura can ask.
+   * Defaults to what the process's own stdout supports, honouring the CLI and environment color
+   * policy. Always no color when `stdout` is injected, since neither that stream nor the
+   * surrounding process's `FORCE_COLOR` says anything about the destination — set this to ask for
+   * color there. An explicit value stays authoritative unless the command line says `--no-color`.
    */
   readonly colorDepth?: number | undefined;
   /** Directory the command was invoked from. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryaura/aura-cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The composable Aura CLI runtime and official plugin distribution.",
   "keywords": [
     "agent",
@@ -50,18 +50,18 @@
     "toml-eslint-parser": "^1.0.3",
     "typanion": "3.14.0",
     "undici": "7.29.0",
-    "@tryaura/aura-sdk": "0.1.0"
+    "@tryaura/aura-sdk": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "24.13.3",
     "ajv": "8.20.0",
     "vitest": "4.1.10",
-    "@tryaura/adapter-claude-code": "0.0.0",
     "@tryaura/adapter-cursor": "0.0.0",
-    "@tryaura/checks-core": "0.0.0",
     "@tryaura/adapter-codex": "0.0.0",
-    "@tryaura/content-official": "0.0.0",
-    "@tryaura/core": "0.0.0"
+    "@tryaura/adapter-claude-code": "0.0.0",
+    "@tryaura/checks-core": "0.0.0",
+    "@tryaura/core": "0.0.0",
+    "@tryaura/content-official": "0.0.0"
   },
   "engines": {
     "node": ">=24"

package/schema/check-output-v1.schema.json

@@ -21,7 +21,7 @@
       "required": ["label", "layer"],
       "properties": {
         "label": { "type": "string" },
-        "layer": { "enum": ["cli", "default", "distro", "manifest", "preset"] }
+        "layer": { "enum": ["cli", "default", "distro", "manifest", "preset", "repo"] }
       }
     },
     "summary": {
@@ -61,6 +61,21 @@
         "phase": { "enum": ["check", "detect", "files", "fix", "parse", "read", "support"] }
       }
     },
+    "configuration": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "repositoryPreset": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["path", "status"],
+          "properties": {
+            "path": { "type": "string" },
+            "status": { "enum": ["applied", "held"] }
+          }
+        }
+      }
+    },
     "support": {
       "type": "object",
       "additionalProperties": false,
@@ -186,6 +201,7 @@
       ],
       "properties": {
         "apps": { "type": "array", "items": { "$ref": "#/$defs/app" } },
+        "configuration": { "$ref": "#/$defs/configuration" },
         "diagnostics": { "type": "array", "items": { "$ref": "#/$defs/diagnostic" } },
         "findings": { "type": "array", "items": { "$ref": "#/$defs/finding" } },
         "fixes": { "type": "array", "items": { "$ref": "#/$defs/fix" } },
@@ -225,6 +241,7 @@
         "title"
       ],
       "properties": {
+        "configuration": { "$ref": "#/$defs/configuration" },
         "enabled": { "type": "boolean" },
         "explain": { "type": "string" },
         "fixability": { "enum": ["auto", "guided", "manual"] },