@logbookfordevs/afk 0.5.2

package/dist/manifest-show.js

@@ -0,0 +1,207 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { sectionTitle, muted } from "./brand.js";
+import { localManifestDir } from "./manifest.js";
+import { bold, paint, reset, terminalPalette } from "./terminal-theme.js";
+const categories = [
+    { id: "rules", label: "Rules", filename: "rules.json" },
+    { id: "skills", label: "Skills", filename: "skills.json" },
+    { id: "mcps", label: "MCPs", filename: "mcps.json" },
+    { id: "utils", label: "Utils", filename: "utils.json" },
+    { id: "hooks", label: "Hooks", filename: "hooks.json" },
+    { id: "presets", label: "Presets", filename: "presets.json" },
+];
+export function runManifestShow(runtime, options) {
+    const selected = selectedCategories(options);
+    const manifestDir = manifestShowDir(options);
+    const scopeLabel = options.setupScope === "project" ? "Project" : "Global";
+    runtime.io.stdout("");
+    runtime.io.stdout(sectionTitle("AFK manifests"));
+    runtime.io.stdout(`${muted("Scope")} ${scopeBadge(scopeLabel)}  ${muted("Directory")} ${manifestDir}`);
+    for (const category of selected) {
+        const loaded = loadManifest(manifestDir, category.filename);
+        runtime.io.stdout(renderCardHeader(category.label, loaded));
+        if (!loaded.content) {
+            runtime.io.stdout(`${muted("  status")} ${paint(terminalPalette.ember, "missing")}`);
+            continue;
+        }
+        runtime.io.stdout(renderManifestSummary(category.id, loaded.content));
+    }
+    return 0;
+}
+function selectedCategories(options) {
+    const flags = options.selectedManifestCategories;
+    if (flags.length === 0) {
+        return categories.filter((category) => category.id !== "presets");
+    }
+    return categories.filter((category) => flags.includes(category.id));
+}
+function manifestShowDir(options) {
+    return options.setupScope === "project" ? join(options.cwd, "afk", "manifests") : localManifestDir(options.homeDir);
+}
+function loadManifest(manifestDir, filename) {
+    const localPath = join(manifestDir, filename);
+    if (existsSync(localPath)) {
+        return {
+            source: "local",
+            path: localPath,
+            content: JSON.parse(readFileSync(localPath, "utf8")),
+        };
+    }
+    return {
+        source: "missing",
+        path: localPath,
+        content: null,
+    };
+}
+function renderCardHeader(label, loaded) {
+    const status = loaded.source === "missing" ? paint(terminalPalette.ember, "missing") : paint(terminalPalette.harbor, "ready");
+    return [
+        "",
+        `${paint(terminalPalette.brass, "┌")} ${bold}${label}${reset} ${muted(`(${loaded.source})`)} ${status}`,
+        `${muted("  file")} ${loaded.path}`,
+    ].join("\n");
+}
+function renderManifestSummary(category, manifest) {
+    if (!isRecord(manifest)) {
+        return "- Invalid manifest shape";
+    }
+    switch (category) {
+        case "rules":
+            return renderRules(manifest);
+        case "skills":
+            return renderSkills(manifest);
+        case "mcps":
+            return renderItems(manifest, "MCP");
+        case "utils":
+            return renderUtils(manifest);
+        case "hooks":
+            return renderHooks(manifest);
+        case "presets":
+            return renderPresets(manifest);
+    }
+}
+function renderRules(manifest) {
+    const lines = [summaryLine("version", valueOrUnknown(manifest.version))];
+    if (typeof manifest.source === "string") {
+        lines.push(summaryLine("source", manifest.source));
+    }
+    if (typeof manifest.url === "string") {
+        lines.push(summaryLine("url", manifest.url || "(empty)"));
+    }
+    if (Array.isArray(manifest.files)) {
+        lines.push(summaryLine("files", String(manifest.files.length)));
+        for (const item of manifest.files) {
+            if (!isRecord(item)) {
+                continue;
+            }
+            lines.push(itemLine(`${String(item.id ?? "unnamed")} ${muted(String(item.path ?? item.url ?? "(no path)"))}${defaultSuffix(item.default)}`));
+        }
+    }
+    return lines.join("\n");
+}
+function renderSkills(manifest) {
+    return [
+        summaryLine("version", valueOrUnknown(manifest.version)),
+        summaryLine("default source", typeof manifest.defaultSource === "string" && manifest.defaultSource ? manifest.defaultSource : "(none)"),
+        ...renderItemList(manifest.items, "skill", (item) => {
+            const args = Array.isArray(item.args) && item.args.length > 0 ? item.args.filter((value) => typeof value === "string").join(" ") : "";
+            const auto = item.autoInvocation === false ? ` ${paint(terminalPalette.ember, "auto:off")}` : "";
+            return sourceItemLine(`${labelFor(item)}${defaultSuffix(item.default)}${auto}`, args);
+        }),
+    ].join("\n");
+}
+function renderUtils(manifest) {
+    return [
+        summaryLine("version", valueOrUnknown(manifest.version)),
+        ...renderItemList(manifest.items, "utility", (item) => {
+            const description = typeof item.description === "string" ? item.description : "";
+            return sourceItemLine(`${labelFor(item)}${defaultSuffix(item.default)}`, description);
+        }),
+    ].join("\n");
+}
+function renderHooks(manifest) {
+    return [
+        summaryLine("version", valueOrUnknown(manifest.version)),
+        ...renderItemList(manifest.items, "hook", (item) => {
+            const agents = Array.isArray(item.agents) ? ` [${item.agents.filter((value) => typeof value === "string").join(", ")}]` : "";
+            const description = typeof item.description === "string" ? item.description : "";
+            return sourceItemLine(`${labelFor(item)}${defaultSuffix(item.default)}${agents}`, description);
+        }),
+    ].join("\n");
+}
+function renderPresets(manifest) {
+    return [
+        summaryLine("version", valueOrUnknown(manifest.version)),
+        summaryLine("defaults source", typeof manifest.defaultsSource === "string" && manifest.defaultsSource ? manifest.defaultsSource : "(none)"),
+        ...renderItemList(manifest.presets, "preset", (item) => {
+            const areas = Array.isArray(item.areas) ? ` [${item.areas.filter((value) => typeof value === "string").join(", ")}]` : "";
+            return `${labelFor(item)}${areas}`;
+        }),
+    ].join("\n");
+}
+function renderItems(manifest, singular) {
+    return [
+        summaryLine("version", valueOrUnknown(manifest.version)),
+        ...(typeof manifest.source === "string" ? [summaryLine("source", manifest.source)] : []),
+        ...renderItemList(manifest.items, singular, (item) => {
+            const source = item.url ?? item.source ?? "";
+            return sourceItemLine(`${labelFor(item)}${defaultSuffix(item.default)}`, typeof source === "string" ? source : "");
+        }),
+    ].join("\n");
+}
+function renderItemList(items, singular, format) {
+    if (!Array.isArray(items) || items.length === 0) {
+        return [summaryLine(pluralize(singular).toLowerCase(), "0")];
+    }
+    const records = items.filter(isRecord);
+    const selected = records.filter((item) => item.default === true).length;
+    return [
+        summaryLine(pluralize(singular).toLowerCase(), `${records.length}${selected > 0 ? ` (${selected} default)` : ""}`),
+        ...records.map((item) => itemLine(format(item))),
+    ];
+}
+function labelFor(item) {
+    const id = typeof item.id === "string" ? item.id : "unnamed";
+    const label = typeof item.label === "string" && item.label !== id ? ` (${item.label})` : "";
+    return `${id}${label}`;
+}
+function defaultSuffix(value) {
+    return value === true ? ` ${paint(terminalPalette.harbor, "[default]")}` : "";
+}
+function summaryLine(label, value) {
+    return `${muted(`  ${label}`)} ${value}`;
+}
+function itemLine(value) {
+    return `${paint(terminalPalette.brass, "  •")} ${value}`;
+}
+function sourceItemLine(title, source) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+        return title;
+    }
+    return `${title}\n${muted(`    ${truncateMiddle(trimmed, 96)}`)}`;
+}
+function scopeBadge(value) {
+    return paint(value === "Project" ? terminalPalette.harbor : terminalPalette.brass, value);
+}
+function valueOrUnknown(value) {
+    return value === undefined || value === null ? "unknown" : String(value);
+}
+function pluralize(value) {
+    if (value === "utility") {
+        return "Utilities";
+    }
+    return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}s`;
+}
+function truncateMiddle(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    const marker = "...";
+    const sideLength = Math.floor((maxLength - marker.length) / 2);
+    return `${value.slice(0, sideLength)}${marker}${value.slice(value.length - sideLength)}`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/manifest.js

@@ -0,0 +1,409 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { manifestPath } from "./paths.js";
+const manifestNames = ["skills.json", "mcps.json", "presets.json", "rules.json", "utils.json", "hooks.json"];
+const rawBaseUrl = "https://raw.githubusercontent.com/logbookfordevs/ai-field-kit";
+const builtInDefaultsSource = "logbookfordevs/ai-field-kit";
+export function localAfkDir(homeDir) {
+    return join(homeDir, ".agents", "afk");
+}
+export function localManifestDir(homeDir) {
+    return join(localAfkDir(homeDir), "manifests");
+}
+export function projectManifestDir(cwd) {
+    return join(cwd, "afk", "manifests");
+}
+export async function ensureLocalManifests(options) {
+    const operations = [];
+    const manifestDir = manifestDirForOptions(options);
+    const effectiveDefaultsSource = options.defaultsSource || rememberedDefaultsSource(manifestDir) || builtInDefaultsSource;
+    const shouldRefreshDefaults = options.refreshDefaults || Boolean(options.defaultsSource);
+    if (!existsSync(manifestDir)) {
+        operations.push({ type: "mkdir", path: manifestDir });
+    }
+    for (const name of manifestNames) {
+        const target = join(manifestDir, name);
+        if (!shouldRefreshDefaults && existsSync(target)) {
+            const migrated = migrateLocalManifest(name, readFileSync(target, "utf8"));
+            if (migrated) {
+                operations.push({ type: "write", path: target, content: migrated });
+            }
+            continue;
+        }
+        const content = options.empty
+            ? emptyManifestContent(name, options, effectiveDefaultsSource)
+            : await defaultManifestContent(name, options, effectiveDefaultsSource);
+        if (content) {
+            operations.push({ type: "write", path: target, content });
+        }
+        else if (existsSync(target)) {
+            operations.push({ type: "skip", path: target, reason: "not provided by defaults source" });
+        }
+        else {
+            operations.push({ type: "write", path: target, content: emptyManifestContent(name, options, effectiveDefaultsSource) });
+        }
+    }
+    return operations;
+}
+export function loadSkillManifest(options) {
+    return parseLocalManifest(options.homeDir, "skills.json", isSkillManifest);
+}
+export function loadMcpManifest(options) {
+    return parseLocalManifest(options.homeDir, "mcps.json", isMcpManifest);
+}
+export function loadRulesManifest(options) {
+    return parseLocalManifest(options.homeDir, "rules.json", isRulesManifest);
+}
+export function loadUtilityManifest(options) {
+    return parseLocalManifest(options.homeDir, "utils.json", isUtilityManifest);
+}
+export function loadHookManifest(options) {
+    return parseLocalManifest(options.homeDir, "hooks.json", isHookManifest);
+}
+function parseLocalManifest(homeDir, name, guard) {
+    const path = join(localManifestDir(homeDir), name);
+    if (!existsSync(path)) {
+        throw new Error(`Missing AFK manifest: ${path}. Run "afk setup refresh" to prepare local manifests.`);
+    }
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!guard(parsed)) {
+        throw new Error(`Invalid AFK manifest: ${path}`);
+    }
+    return parsed;
+}
+async function defaultManifestContent(name, options, defaultsSource) {
+    if (name === "presets.json") {
+        const content = await fetchDefaultManifest(name, options, defaultsSource);
+        return content ? withRememberedDefaultsSource(content, defaultsSource) : null;
+    }
+    return fetchDefaultManifest(name, options, defaultsSource);
+}
+async function fetchDefaultManifest(name, options, defaultsSource) {
+    if (options.rulesSource === "local") {
+        return readLocalPackageManifest(name, options);
+    }
+    const localContent = readLocalDefaultManifest(name, options, defaultsSource);
+    if (localContent) {
+        return localContent;
+    }
+    try {
+        for (const baseUrl of defaultsManifestBaseUrls(defaultsSource, options.rulesRef)) {
+            const url = `${baseUrl}/${name}`;
+            const response = await fetch(url);
+            if (response.ok) {
+                return ensureTrailingNewline(await response.text());
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function readLocalPackageManifest(name, options) {
+    const cwd = options.cwd ?? process.cwd();
+    const candidates = [
+        join(cwd, "packages", "afk", "manifests", name),
+        join(cwd, "manifests", name),
+        join(options.repoDir, "packages", "afk", "manifests", name),
+        manifestPath(name),
+    ];
+    for (const candidate of unique(candidates)) {
+        if (existsSync(candidate)) {
+            return ensureTrailingNewline(readFileSync(candidate, "utf8"));
+        }
+    }
+    return null;
+}
+function readLocalDefaultManifest(name, options, defaultsSource) {
+    const normalized = defaultsSource.trim().replace(/\/$/, "");
+    if (!normalized || normalized.startsWith("http://") || normalized.startsWith("https://") || normalized.includes("github.com")) {
+        return null;
+    }
+    if (/^[^/\s]+\/[^/\s]+$/.test(normalized)) {
+        return null;
+    }
+    const basePath = isAbsolute(normalized) ? normalized : resolve(options.cwd ?? process.cwd(), normalized);
+    const candidates = [
+        join(basePath, name),
+        join(basePath, "afk", "manifests", name),
+    ];
+    for (const candidate of unique(candidates)) {
+        if (existsSync(candidate)) {
+            return ensureTrailingNewline(readFileSync(candidate, "utf8"));
+        }
+    }
+    return null;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function manifestDirForOptions(options) {
+    return options.manifestLocal ? projectManifestDir(options.cwd ?? process.cwd()) : localManifestDir(options.homeDir);
+}
+function rememberedDefaultsSource(manifestDir) {
+    const path = join(manifestDir, "presets.json");
+    if (!existsSync(path)) {
+        return "";
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (isRecord(parsed) && typeof parsed.defaultsSource === "string") {
+            return parsed.defaultsSource.trim();
+        }
+    }
+    catch {
+        return "";
+    }
+    return "";
+}
+export function defaultsManifestBaseUrl(source, ref) {
+    return defaultsManifestBaseUrls(source, ref)[0] ?? `${rawBaseUrl}/${encodeURIComponent(ref)}/packages/afk/manifests`;
+}
+export function defaultsManifestBaseUrls(source, ref) {
+    const normalized = source.trim().replace(/\/$/, "");
+    if (!normalized) {
+        return [`${rawBaseUrl}/${encodeURIComponent(ref)}/packages/afk/manifests`];
+    }
+    const rawMatch = normalized.match(/^https:\/\/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)\/(.+)$/);
+    if (rawMatch) {
+        const [, owner, repo, sourceRef, path] = rawMatch;
+        return [`https://raw.githubusercontent.com/${owner}/${repo}/${sourceRef}/${path?.replace(/\/$/, "")}`];
+    }
+    const githubTreeMatch = normalized.match(/^(?:https:\/\/)?github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)$/);
+    if (githubTreeMatch) {
+        const [, owner, repo, sourceRef, path] = githubTreeMatch;
+        return [`https://raw.githubusercontent.com/${owner}/${repo}/${sourceRef}/${path?.replace(/\/$/, "")}`];
+    }
+    const githubRepoMatch = normalized.match(/^(?:https:\/\/)?github\.com\/([^/]+)\/([^/]+)$/);
+    if (githubRepoMatch) {
+        const [, owner, repo] = githubRepoMatch;
+        return defaultRepoManifestUrls(owner ?? "", repo ?? "", ref);
+    }
+    const shorthandMatch = normalized.match(/^([^/\s]+)\/([^/\s]+)$/);
+    if (shorthandMatch) {
+        const [, owner, repo] = shorthandMatch;
+        return defaultRepoManifestUrls(owner ?? "", repo ?? "", ref);
+    }
+    return [normalized];
+}
+function defaultRepoManifestUrls(owner, repo, ref) {
+    const base = `https://raw.githubusercontent.com/${owner}/${repo}/${encodeURIComponent(ref)}`;
+    return [
+        `${base}/afk/manifests`,
+        `${base}/packages/afk/manifests`,
+    ];
+}
+function emptyManifestContent(name, options, defaultsSource) {
+    if (name === "skills.json") {
+        return `${JSON.stringify({ version: 1, defaultSource: "", items: [] }, null, 2)}\n`;
+    }
+    if (name === "mcps.json") {
+        return `${JSON.stringify({ version: 1, items: [] }, null, 2)}\n`;
+    }
+    if (name === "rules.json") {
+        return `${JSON.stringify({ version: 1, source: "github", url: "" }, null, 2)}\n`;
+    }
+    if (name === "utils.json") {
+        return `${JSON.stringify({ version: 1, items: [] }, null, 2)}\n`;
+    }
+    if (name === "hooks.json") {
+        return `${JSON.stringify({ version: 1, items: [] }, null, 2)}\n`;
+    }
+    return `${JSON.stringify({ version: 1, defaultsSource, presets: [] }, null, 2)}\n`;
+}
+function withRememberedDefaultsSource(content, defaultsSource) {
+    try {
+        const parsed = JSON.parse(content);
+        if (isRecord(parsed)) {
+            return `${JSON.stringify({ ...parsed, defaultsSource }, null, 2)}\n`;
+        }
+    }
+    catch {
+        return content;
+    }
+    return content;
+}
+function ensureTrailingNewline(content) {
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+function migrateLocalManifest(name, content) {
+    if (name === "skills.json") {
+        return migrateSkillsManifest(content);
+    }
+    if (name === "presets.json") {
+        return migratePresetsManifest(content);
+    }
+    if (name !== "mcps.json") {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (!isMcpManifest(parsed)) {
+        return null;
+    }
+    let changed = false;
+    const items = parsed.items.map((item) => {
+        if (item.id !== "stitch" || item.source !== "https://stitch.googleapis.com/mcp") {
+            return item;
+        }
+        const args = removeArgPair(item.args, "--header", "X-Goog-Api-Key: KEY_STITCH");
+        if (args.length === item.args.length) {
+            return item;
+        }
+        changed = true;
+        return { ...item, args };
+    });
+    if (!changed) {
+        return null;
+    }
+    return `${JSON.stringify({ ...parsed, version: Math.max(parsed.version, 2), items }, null, 2)}\n`;
+}
+function migrateSkillsManifest(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (!isSkillManifest(parsed)) {
+        return null;
+    }
+    let changed = false;
+    const items = parsed.items.map((item) => {
+        if (item.autoInvocation !== undefined) {
+            return item;
+        }
+        changed = true;
+        return { ...item, autoInvocation: true };
+    });
+    if (!changed) {
+        return null;
+    }
+    return `${JSON.stringify({ ...parsed, items }, null, 2)}\n`;
+}
+function migratePresetsManifest(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed) || typeof parsed.version !== "number" || !Array.isArray(parsed.presets) || typeof parsed.defaultsSource === "string") {
+        return null;
+    }
+    return `${JSON.stringify({ ...parsed, defaultsSource: builtInDefaultsSource }, null, 2)}\n`;
+}
+function removeArgPair(args, flag, value) {
+    const next = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === flag && args[index + 1] === value) {
+            index += 1;
+            continue;
+        }
+        const arg = args[index];
+        if (arg) {
+            next.push(arg);
+        }
+    }
+    return next;
+}
+export function writeLocalManifestNow(homeDir, name, content) {
+    const path = join(localManifestDir(homeDir), name);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isSkillManifest(value) {
+    if (!isRecord(value) || typeof value.version !== "number" || typeof value.defaultSource !== "string" || !Array.isArray(value.items)) {
+        return false;
+    }
+    return value.items.every((item) => {
+        if (!isRecord(item)) {
+            return false;
+        }
+        return (typeof item.id === "string" &&
+            typeof item.label === "string" &&
+            typeof item.source === "string" &&
+            isStringArray(item.args) &&
+            typeof item.default === "boolean" &&
+            (item.autoInvocation === undefined || typeof item.autoInvocation === "boolean"));
+    });
+}
+function isMcpManifest(value) {
+    if (!isRecord(value) || typeof value.version !== "number" || !Array.isArray(value.items)) {
+        return false;
+    }
+    return value.items.every((item) => {
+        if (!isRecord(item)) {
+            return false;
+        }
+        return (typeof item.id === "string" &&
+            typeof item.label === "string" &&
+            typeof item.source === "string" &&
+            isStringArray(item.args) &&
+            typeof item.default === "boolean");
+    });
+}
+function isRulesManifest(value) {
+    if (!isRecord(value) || typeof value.version !== "number" || (value.source !== "github" && value.source !== "local")) {
+        return false;
+    }
+    return typeof value.url === "string";
+}
+function isUtilityManifest(value) {
+    if (!isRecord(value) || typeof value.version !== "number" || !Array.isArray(value.items)) {
+        return false;
+    }
+    return value.items.every((item) => {
+        if (!isRecord(item) || !isRecord(item.install)) {
+            return false;
+        }
+        return (typeof item.id === "string" &&
+            typeof item.label === "string" &&
+            typeof item.description === "string" &&
+            typeof item.install.command === "string" &&
+            isStringArray(item.install.args) &&
+            (item.postInstall === undefined || item.postInstall === "rtk-init" || isUtilityPostInstallCommand(item.postInstall)) &&
+            typeof item.default === "boolean");
+    });
+}
+function isUtilityPostInstallCommand(value) {
+    return (isRecord(value) &&
+        (value.label === undefined || typeof value.label === "string") &&
+        typeof value.command === "string" &&
+        isStringArray(value.args));
+}
+function isHookManifest(value) {
+    if (!isRecord(value) || typeof value.version !== "number" || !Array.isArray(value.items)) {
+        return false;
+    }
+    return value.items.every((item) => {
+        if (!isRecord(item)) {
+            return false;
+        }
+        return (typeof item.id === "string" &&
+            typeof item.label === "string" &&
+            typeof item.description === "string" &&
+            typeof item.source === "string" &&
+            typeof item.command === "string" &&
+            isStringArray(item.args) &&
+            Array.isArray(item.events) &&
+            item.events.every((event) => event === "stop") &&
+            Array.isArray(item.agents) &&
+            item.agents.every((agent) => agent === "codex" || agent === "claude" || agent === "cursor-local") &&
+            typeof item.default === "boolean");
+    });
+}

package/dist/paths.js

@@ -0,0 +1,17 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export function packageRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+}
+export function defaultRepoDir() {
+    return resolve(packageRoot(), "..", "..");
+}
+export function resolveHome(input = process.env) {
+    return input.HOME ?? input.USERPROFILE ?? process.cwd();
+}
+export function resolveRepoDir(input = process.env) {
+    return input.AI_RULES_REPO ? resolve(input.AI_RULES_REPO) : defaultRepoDir();
+}
+export function manifestPath(name) {
+    return resolve(packageRoot(), "manifests", name);
+}