@logbookfordevs/afk 0.5.2

package/dist/prompt-ui.js

@@ -0,0 +1,109 @@
+import { bold, paint, reset, terminalPalette } from "./terminal-theme.js";
+let promptStep = 0;
+export const DEFAULT_CHECKED = false;
+export const defaultCheckedDetail = DEFAULT_CHECKED
+    ? "Everything starts selected. Use space to unselect anything you want to skip."
+    : "Nothing starts selected. Use space to choose what you want to include.";
+export function resetPromptSteps() {
+    promptStep = 0;
+}
+export function renderPromptStep(title, detail) {
+    promptStep += 1;
+    const step = String(promptStep).padStart(2, "0");
+    const lines = [
+        "",
+        `${chartLine("┌")}   ${badge(`step ${step}`)} ${bold}${title}${reset}`,
+    ];
+    if (detail) {
+        lines.push(`${chartLine("│")}   ${muted(detail)}`);
+    }
+    return lines.join("\n");
+}
+export const afkSelectTheme = {
+    prefix: {
+        idle: sea("◇"),
+        done: signal("◆"),
+    },
+    icon: {
+        cursor: brass("◆"),
+    },
+    style: {
+        answer: (text) => sea(text),
+        message: (text) => `${bold}${text}${reset}`,
+        description: (text) => muted(text),
+        highlight: (text) => brass(text),
+        help: (text) => muted(text),
+        key: (text) => sea(`<${text}>`),
+        keysHelpTip: (keys) => formatKeys(keys),
+    },
+};
+export const afkCheckboxTheme = {
+    prefix: {
+        idle: sea("◇"),
+        done: signal("◆"),
+    },
+    icon: {
+        checked: brass("■"),
+        unchecked: muted("□"),
+        cursor: signal("◆ "),
+    },
+    style: {
+        answer: (text) => sea(text),
+        message: (text) => `${bold}${text}${reset}`,
+        description: (text) => muted(text),
+        highlight: (text) => brass(text),
+        help: (text) => muted(text),
+        key: (text) => sea(`<${text}>`),
+        disabledChoice: (text) => muted(`- ${text}`),
+        renderSelectedChoices: (selectedChoices) => {
+            if (selectedChoices.length === 0) {
+                return "none selected";
+            }
+            if (selectedChoices.length <= 3) {
+                return selectedChoices.map((choice) => choice.short).join(", ");
+            }
+            return `${selectedChoices.length} selected`;
+        },
+        keysHelpTip: (keys) => formatKeys(keys),
+    },
+    helpMode: "always",
+};
+export const afkPromptTheme = {
+    prefix: {
+        idle: sea("◇"),
+        done: signal("◆"),
+    },
+    style: {
+        answer: (text) => sea(text),
+        message: (text) => `${bold}${text}${reset}`,
+        error: (text) => ember(`> ${text}`),
+        defaultAnswer: (text) => muted(`(${text})`),
+        help: (text) => muted(text),
+        highlight: (text) => brass(text),
+        key: (text) => sea(`<${text}>`),
+    },
+};
+function formatKeys(keys) {
+    return muted(keys.map(([key, action]) => `${sea(key)} ${action}`).join("  ·  "));
+}
+function badge(value) {
+    return `${signal(" ")}${signal(value)}${signal(" ")}`;
+}
+function sea(value) {
+    return paint(terminalPalette.harbor, value);
+}
+function brass(value) {
+    return paint(terminalPalette.brass, value);
+}
+function signal(value) {
+    return paint(terminalPalette.rust, value);
+}
+function muted(value) {
+    return paint(terminalPalette.driftwood, value);
+}
+function ember(value) {
+    return paint(terminalPalette.ember, value);
+}
+function chartLine(value) {
+    return paint(terminalPalette.sienna, value);
+}

package/dist/prompt.js

@@ -0,0 +1,8 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+export async function confirm(message) {
+    const reader = createInterface({ input, output });
+    const answer = await reader.question(`${message} [y/N] `);
+    reader.close();
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+}

package/dist/rules.js

@@ -0,0 +1,209 @@
+import { dirname, join } from "node:path";
+import { applyOperation, backupTarget, formatOperation, isSymlink, pathExists, readText, summarizeOperations } from "./fs-utils.js";
+import { filterAgents } from "./agents.js";
+import { loadRulesManifest } from "./manifest.js";
+const afkRegionStart = "<!-- AFK:RULES:START -->";
+const afkRegionEnd = "<!-- AFK:RULES:END -->";
+const legacyImportStart = "<!-- AFK:IMPORT:START -->";
+const legacyImportEnd = "<!-- AFK:IMPORT:END -->";
+const globalRulesAgents = ["antigravity", "codex", "opencode"];
+export async function syncRules(runtime, options) {
+    const content = await loadRulesContent(options);
+    const operations = planRulesSync(options, content);
+    if (options.dryRun) {
+        printOperations(runtime, "Rules sync plan", operations);
+        return 0;
+    }
+    for (const operation of operations) {
+        applyOperation(operation);
+    }
+    runtime.io.stdout(`\nRules synced: ${summarizeOperations(operations)}.`);
+    return 0;
+}
+export function planRulesSync(options, content) {
+    const timestamp = compactTimestamp();
+    const operations = [];
+    const normalizedRules = normalizeAfkRules(content.afk);
+    if (options.setupScope === "project") {
+        return planProjectRules(options, normalizedRules, timestamp);
+    }
+    for (const agent of filterAgents(options.agents, globalRulesAgents)) {
+        operations.push(...removeLegacySidecars(dirname(agentRulesDestination(options.homeDir, agent)), timestamp));
+        operations.push(...upsertManagedRulesRegion(agentRulesDestination(options.homeDir, agent), normalizedRules, timestamp));
+    }
+    if (shouldConfigureClaude(options.agents)) {
+        operations.push(...planClaudeRules(options.homeDir, { afk: normalizedRules }, timestamp));
+    }
+    return operations;
+}
+function planProjectRules(options, normalizedRules, timestamp) {
+    const operations = [];
+    const selected = filterAgents(options.agents, ["antigravity", "claude", "codex", "opencode"]);
+    const hostPaths = new Set();
+    for (const agent of selected) {
+        hostPaths.add(projectRulesDestination(options.cwd, agent));
+    }
+    for (const path of hostPaths) {
+        operations.push(...upsertManagedRulesRegion(path, normalizedRules, timestamp));
+    }
+    return operations;
+}
+async function loadRulesContent(options) {
+    const manifest = loadRulesManifest(options);
+    if (!manifest.url) {
+        return { afk: "" };
+    }
+    const source = options.rulesSource === "manifest" ? manifest.source : options.rulesSource;
+    const agents = source === "local"
+        ? await readLocalRule(options.repoDir, localRulesPath(manifest.url))
+        : await fetchGithubRule(manifest.url);
+    return {
+        afk: normalizeAfkRules(agents),
+    };
+}
+async function readLocalRule(repoDir, file) {
+    return readText(join(repoDir, file));
+}
+async function fetchGithubRule(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Could not fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+}
+function localRulesPath(url) {
+    try {
+        const parsed = new URL(url);
+        const rawGithubMatch = parsed.hostname === "raw.githubusercontent.com" ? parsed.pathname.match(/^\/[^/]+\/[^/]+\/[^/]+\/(.+)$/) : null;
+        if (rawGithubMatch?.[1]) {
+            return rawGithubMatch[1];
+        }
+    }
+    catch {
+        return url;
+    }
+    return url.replace(/^\/+/, "");
+}
+function normalizeAfkRules(content) {
+    const withoutImports = content
+        .split(/\r?\n/)
+        .filter((line) => !isMarkdownImportLine(line))
+        .join("\n");
+    return ensureTrailingNewline(withoutImports);
+}
+function isMarkdownImportLine(line) {
+    return /^@[^\s]+\.md$/i.test(line.trim());
+}
+function ensureTrailingNewline(content) {
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+function upsertManagedRulesRegion(path, afkRules, timestamp) {
+    const operations = [];
+    const region = renderManagedRulesRegion(afkRules);
+    if (isSymlink(path)) {
+        const current = pathExists(path) ? readText(path) : "";
+        const next = current ? updateManagedRulesRegion(current, region) : region;
+        operations.push({ type: "remove", path });
+        operations.push({ type: "write", path, content: next });
+        return operations;
+    }
+    if (!pathExists(path)) {
+        operations.push({ type: "write", path, content: region });
+        return operations;
+    }
+    const current = readText(path);
+    const next = updateManagedRulesRegion(current, region);
+    if (current === next) {
+        operations.push({ type: "skip", path, reason: "AFK rules region already current" });
+        return operations;
+    }
+    const backup = backupTarget(path, timestamp);
+    if (backup) {
+        operations.push(backup);
+    }
+    operations.push({ type: "write", path, content: next });
+    return operations;
+}
+function planClaudeRules(homeDir, content, timestamp) {
+    const claudeDir = join(homeDir, ".claude");
+    const operations = [{ type: "mkdir", path: claudeDir }];
+    operations.push(...removeLegacySidecars(claudeDir, timestamp));
+    operations.push(...upsertManagedRulesRegion(join(claudeDir, "CLAUDE.md"), content.afk, timestamp));
+    return operations;
+}
+function shouldConfigureClaude(agents) {
+    return agents.length === 0 || agents.includes("claude");
+}
+function removeLegacySidecars(directory, timestamp) {
+    const operations = [];
+    for (const filename of ["AFK.md", "AFK_WORKFLOW.md"]) {
+        const path = join(directory, filename);
+        if (!pathExists(path) && !isSymlink(path)) {
+            continue;
+        }
+        const backup = backupTarget(path, timestamp);
+        if (backup) {
+            operations.push(backup);
+        }
+        operations.push({ type: "remove", path });
+    }
+    return operations;
+}
+function agentRulesDestination(homeDir, agent) {
+    switch (agent) {
+        case "codex":
+            return join(homeDir, ".codex", "AGENTS.md");
+        case "antigravity":
+            return join(homeDir, ".gemini", "GEMINI.md");
+        case "opencode":
+            return join(homeDir, ".config", "opencode", "AGENTS.md");
+        default:
+            throw new Error(`Unsupported linked rules agent: ${agent}`);
+    }
+}
+function projectRulesDestination(cwd, agent) {
+    switch (agent) {
+        case "claude":
+            return join(cwd, "CLAUDE.md");
+        case "antigravity":
+            return join(cwd, "GEMINI.md");
+        case "codex":
+        case "opencode":
+            return join(cwd, "AGENTS.md");
+        case "cursor-local":
+            return join(cwd, ".cursor", "rules", "afk.mdc");
+    }
+}
+function renderManagedRulesRegion(afkRules) {
+    return ensureTrailingNewline([afkRegionStart, ensureTrailingNewline(afkRules).trimEnd(), afkRegionEnd, ""].join("\n"));
+}
+function updateManagedRulesRegion(current, region) {
+    if (current.includes(afkRegionStart)) {
+        const pattern = new RegExp(`${escapeRegExp(afkRegionStart)}[\\s\\S]*?${escapeRegExp(afkRegionEnd)}\\n?`);
+        return ensureTrailingNewline(current.replace(pattern, region));
+    }
+    if (current.includes(legacyImportStart)) {
+        const pattern = new RegExp(`${escapeRegExp(legacyImportStart)}[\\s\\S]*?${escapeRegExp(legacyImportEnd)}\\n?`);
+        return ensureTrailingNewline(current.replace(pattern, region));
+    }
+    const lines = current.split(/\r?\n/);
+    const firstLocalImportIndex = lines.findIndex((line) => line === "@RTK.md" || line === "<!-- OMC:IMPORT:START -->");
+    if (firstLocalImportIndex >= 0) {
+        const before = lines.slice(0, firstLocalImportIndex).join("\n").trimEnd();
+        const after = lines.slice(firstLocalImportIndex).join("\n").trimStart();
+        return ensureTrailingNewline([before, region, after].filter(Boolean).join("\n\n"));
+    }
+    return `${region}\n${current}`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compactTimestamp() {
+    return new Date().toISOString().replace(/[-:]/g, "").replace(/\..+$/, "").replace("T", "-");
+}
+function printOperations(runtime, title, operations) {
+    runtime.io.stdout(`\n${title}`);
+    for (const operation of operations) {
+        runtime.io.stdout(`- ${formatOperation(operation)}`);
+    }
+}

package/dist/setup.js

@@ -0,0 +1,225 @@
+import { syncRules } from "./rules.js";
+import { syncHooks } from "./hooks.js";
+import { syncSkillInvocationPolicy } from "./skills.js";
+import { buildMcpCommands, buildSkillCommands, buildUtilityCommands, runDelegateCommands } from "./delegates.js";
+import { renderBanner, renderSetupOutro, sectionTitle, muted } from "./brand.js";
+import { selectHooksInstall, selectMcpsInstall, selectRulesSync, selectSetup, selectSkillsInstall, selectUtilsInstall } from "./interactive.js";
+import { applyOperation, formatOperation, summarizeOperations } from "./fs-utils.js";
+import { ensureLocalManifests } from "./manifest.js";
+import { defaultCheckedDetail } from "./prompt-ui.js";
+export async function runSetup(runtime, options) {
+    runtime.io.stdout(renderBanner());
+    if (options.refreshDefaults) {
+        runtime.io.stdout(options.manifestLocal
+            ? "Refreshing project AFK manifests from your configured defaults source."
+            : "Refreshing global AFK manifests from your configured defaults source.");
+        return ensureManifestFiles(runtime, options);
+    }
+    runtime.io.stdout("Choose the parts of your AI field setup you want AFK to prepare.");
+    runtime.io.stdout(muted(defaultCheckedDetail));
+    const manifestCode = await ensureManifestFiles(runtime, options);
+    if (manifestCode !== 0 || options.initOnly) {
+        return manifestCode;
+    }
+    const selection = await selectSetup(options);
+    const selectedOptions = {
+        ...options,
+        agents: selection.agents,
+        setupScope: selection.setupScope,
+        scopeExplicit: true,
+        selectedSkillIds: selection.skillIds,
+        selectedSkillAgentIds: selection.skillAgents,
+        selectedMcpIds: selection.mcpIds,
+        selectedUtilIds: selection.utilIds,
+        selectedHookIds: selection.hookIds,
+    };
+    if (selection.areas.length === 0) {
+        runtime.io.stdout("\nNothing selected. No changes planned.");
+        runtime.io.stdout(renderSetupOutro({
+            dryRun: options.dryRun,
+            failed: false,
+            scopeLabel: scopeLabel(selection.setupScope, options.cwd),
+            areas: ["none"],
+        }));
+        return 0;
+    }
+    runtime.io.stdout("\nSetup path");
+    runtime.io.stdout(`- Scope: ${scopeLabel(selection.setupScope, options.cwd)}`);
+    runtime.io.stdout(`- Areas: ${selection.areas.join(", ")}`);
+    if (selection.agents.length > 0) {
+        runtime.io.stdout(`- Agents: ${selection.agents.join(", ")}`);
+    }
+    if (selection.skillAgents.length > 0) {
+        runtime.io.stdout(`- Additional skill agents: ${selection.skillAgents.join(", ")}`);
+    }
+    const failures = [];
+    for (const area of selection.areas) {
+        runtime.io.stdout(`\n${sectionTitle(areaLabel(area))}`);
+        const areaOptions = area === "hooks" ? { ...selectedOptions, agents: selection.hookAgents } : selectedOptions;
+        const code = await runArea(area, runtime, areaOptions);
+        if (code !== 0) {
+            failures.push({ area, code });
+            runtime.io.stderr(`${areaLabel(area)} failed with exit code ${code}. Continuing with remaining setup areas.`);
+        }
+    }
+    if (failures.length > 0) {
+        runtime.io.stdout("\nSetup completed with failures:");
+        for (const failure of failures) {
+            runtime.io.stdout(`- ${areaLabel(failure.area)} exited with code ${failure.code}`);
+        }
+        runtime.io.stdout(renderSetupOutro({
+            dryRun: options.dryRun,
+            failed: true,
+            scopeLabel: scopeLabel(selection.setupScope, options.cwd),
+            areas: selection.areas.map(areaLabel),
+        }));
+        return failures[0]?.code ?? 1;
+    }
+    runtime.io.stdout(renderSetupOutro({
+        dryRun: options.dryRun,
+        failed: false,
+        scopeLabel: scopeLabel(selection.setupScope, options.cwd),
+        areas: selection.areas.map(areaLabel),
+    }));
+    return 0;
+}
+export async function runArea(area, runtime, options) {
+    const manifestCode = await ensureManifestFiles(runtime, options);
+    if (manifestCode !== 0 || options.initOnly) {
+        return manifestCode;
+    }
+    switch (area) {
+        case "rules": {
+            const selectedOptions = await resolveRulesOptions(options);
+            return syncRules(runtime, selectedOptions);
+        }
+        case "skills": {
+            const selectedOptions = await resolveSkillOptions(options);
+            if (!selectedOptions.yes && selectedOptions.selectedSkillIds.length === 0) {
+                runtime.io.stdout("\nNo skills selected. No changes planned.");
+                return 0;
+            }
+            const code = await runDelegateCommands(runtime, buildSkillCommands(selectedOptions), selectedOptions);
+            if (code === 0) {
+                syncSkillInvocationPolicy(runtime, selectedOptions);
+            }
+            return code;
+        }
+        case "mcps": {
+            const selectedOptions = await resolveMcpOptions(options);
+            if (!selectedOptions.yes && selectedOptions.selectedMcpIds.length === 0) {
+                runtime.io.stdout("\nNo MCPs selected. No changes planned.");
+                return 0;
+            }
+            return runDelegateCommands(runtime, buildMcpCommands(selectedOptions), selectedOptions);
+        }
+        case "utils": {
+            const selectedOptions = await resolveUtilityOptions(options);
+            if (!selectedOptions.yes && selectedOptions.selectedUtilIds.length === 0) {
+                runtime.io.stdout("\nNo utilities selected. No changes planned.");
+                return 0;
+            }
+            return runDelegateCommands(runtime, buildUtilityCommands(selectedOptions), {
+                ...options,
+                continueOnError: true,
+            });
+        }
+        case "hooks": {
+            const selectedOptions = await resolveHookOptions(options);
+            if (!selectedOptions.yes && (selectedOptions.selectedHookIds.length === 0 || selectedOptions.agents.length === 0)) {
+                runtime.io.stdout("\nNo hooks selected. No changes planned.");
+                return 0;
+            }
+            return syncHooks(runtime, selectedOptions);
+        }
+    }
+}
+async function resolveRulesOptions(options) {
+    if (options.yes || options.agents.length > 0) {
+        return options;
+    }
+    const selection = await selectRulesSync(options);
+    return {
+        ...options,
+        agents: selection.agents,
+    };
+}
+async function resolveSkillOptions(options) {
+    if (options.yes || options.selectedSkillIds.length > 0) {
+        return options;
+    }
+    const selection = await selectSkillsInstall(options);
+    return {
+        ...options,
+        selectedSkillIds: selection.skillIds,
+        selectedSkillAgentIds: selection.skillAgents,
+    };
+}
+async function resolveMcpOptions(options) {
+    if (options.yes || options.selectedMcpIds.length > 0) {
+        return options;
+    }
+    const selection = await selectMcpsInstall(options);
+    return {
+        ...options,
+        agents: selection.agents,
+        selectedMcpIds: selection.mcpIds,
+    };
+}
+async function resolveUtilityOptions(options) {
+    if (options.yes || options.selectedUtilIds.length > 0) {
+        return options;
+    }
+    const selection = await selectUtilsInstall(options);
+    return {
+        ...options,
+        agents: selection.agents,
+        selectedUtilIds: selection.utilIds,
+    };
+}
+async function resolveHookOptions(options) {
+    if (options.yes || options.selectedHookIds.length > 0) {
+        return options;
+    }
+    const selection = await selectHooksInstall(options);
+    return {
+        ...options,
+        agents: selection.agents,
+        selectedHookIds: selection.hookIds,
+    };
+}
+async function ensureManifestFiles(runtime, options) {
+    const operations = await ensureLocalManifests(options);
+    if (operations.length === 0) {
+        return 0;
+    }
+    if (options.dryRun) {
+        runtime.io.stdout(`\n${sectionTitle("Local Manifests")}`);
+        for (const operation of operations) {
+            runtime.io.stdout(`- ${formatOperation(operation)}`);
+        }
+        return 0;
+    }
+    for (const operation of operations) {
+        applyOperation(operation);
+    }
+    runtime.io.stdout(`\nLocal manifests prepared: ${summarizeOperations(operations)}.`);
+    return 0;
+}
+function areaLabel(area) {
+    switch (area) {
+        case "rules":
+            return "Rules";
+        case "skills":
+            return "Skills";
+        case "mcps":
+            return "MCPs";
+        case "utils":
+            return "Utils";
+        case "hooks":
+            return "Hooks";
+    }
+}
+function scopeLabel(scope, cwd) {
+    return scope === "global" ? "Global field kit" : `This project only (${cwd})`;
+}

package/dist/skills.js

@@ -0,0 +1,114 @@
+import { realpathSync } from "node:fs";
+import { join } from "node:path";
+import { applyOperation, formatOperation, pathExists, readText, summarizeOperations } from "./fs-utils.js";
+import { loadSkillManifest } from "./manifest.js";
+export function planSkillInvocationPolicy(options) {
+    const manifest = loadSkillManifest(options);
+    const selected = options.selectedSkillIds.length > 0
+        ? manifest.items.filter((item) => options.selectedSkillIds.includes(item.id))
+        : manifest.items.filter((item) => item.default);
+    const manualSkills = selected.filter((item) => item.autoInvocation === false);
+    const operations = [];
+    const plannedRealPaths = new Set();
+    for (const item of manualSkills) {
+        for (const skillDir of skillDirectories(options, item)) {
+            operations.push(...planManualSkillInvocation(skillDir, plannedRealPaths));
+        }
+    }
+    return operations;
+}
+export function syncSkillInvocationPolicy(runtime, options) {
+    const operations = planSkillInvocationPolicy(options);
+    if (operations.length === 0) {
+        return;
+    }
+    if (options.dryRun) {
+        runtime.io.stdout("\nSkill invocation policy plan");
+        for (const operation of operations) {
+            runtime.io.stdout(`- ${formatOperation(operation)}`);
+        }
+        return;
+    }
+    for (const operation of operations) {
+        applyOperation(operation);
+    }
+    runtime.io.stdout(`\nSkill invocation policies synced: ${summarizeOperations(operations)}.`);
+}
+function skillDirectories(options, item) {
+    const root = options.setupScope === "global" ? options.homeDir : options.cwd;
+    return [
+        join(root, ".agents", "skills", item.id),
+        join(root, ".claude", "skills", item.id),
+    ];
+}
+function planManualSkillInvocation(skillDir, plannedRealPaths) {
+    const skillMd = join(skillDir, "SKILL.md");
+    const openaiYaml = join(skillDir, "agents", "openai.yaml");
+    const operations = [];
+    if (!pathExists(skillMd)) {
+        return operations;
+    }
+    const skillMdRealPath = realPathOrSelf(skillMd);
+    if (!plannedRealPaths.has(skillMdRealPath)) {
+        plannedRealPaths.add(skillMdRealPath);
+        const nextSkillMd = upsertFrontmatterBoolean(readText(skillMd), "disable-model-invocation", true);
+        if (nextSkillMd !== readText(skillMd)) {
+            operations.push({ type: "write", path: skillMd, content: nextSkillMd });
+        }
+    }
+    const openaiYamlRealPath = realPathOrSelf(openaiYaml);
+    if (!plannedRealPaths.has(openaiYamlRealPath)) {
+        plannedRealPaths.add(openaiYamlRealPath);
+        const currentOpenAiYaml = pathExists(openaiYaml) ? readText(openaiYaml) : "";
+        const nextOpenAiYaml = upsertOpenAiImplicitInvocation(currentOpenAiYaml, false);
+        if (nextOpenAiYaml !== currentOpenAiYaml) {
+            operations.push({ type: "write", path: openaiYaml, content: nextOpenAiYaml });
+        }
+    }
+    return operations;
+}
+export function upsertFrontmatterBoolean(markdown, key, value) {
+    const line = `${key}: ${value ? "true" : "false"}`;
+    if (!markdown.startsWith("---\n")) {
+        return `---\n${line}\n---\n\n${markdown}`;
+    }
+    const end = markdown.indexOf("\n---", 4);
+    if (end === -1) {
+        return `---\n${line}\n---\n\n${markdown.replace(/^---\n?/, "")}`;
+    }
+    const frontmatter = markdown.slice(4, end);
+    const body = markdown.slice(end);
+    const pattern = new RegExp(`^${escapeRegExp(key)}:\\s*(true|false)\\s*$`, "m");
+    const nextFrontmatter = (pattern.test(frontmatter)
+        ? frontmatter.replace(pattern, line)
+        : `${frontmatter.trimEnd()}\n${line}`)
+        .trimEnd();
+    return `---\n${nextFrontmatter}${body}`;
+}
+export function upsertOpenAiImplicitInvocation(yaml, value) {
+    const line = `  allow_implicit_invocation: ${value ? "true" : "false"}`;
+    if (!yaml.trim()) {
+        return `policy:\n${line}\n`;
+    }
+    if (/^\s*allow_implicit_invocation:\s*(true|false)\s*$/m.test(yaml)) {
+        return ensureTrailingNewline(yaml.replace(/^\s*allow_implicit_invocation:\s*(true|false)\s*$/m, line));
+    }
+    if (/^policy:\s*$/m.test(yaml)) {
+        return ensureTrailingNewline(yaml.replace(/^policy:\s*$/m, `policy:\n${line}`));
+    }
+    return `${ensureTrailingNewline(yaml)}policy:\n${line}\n`;
+}
+function realPathOrSelf(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}
+function ensureTrailingNewline(value) {
+    return value.endsWith("\n") ? value : `${value}\n`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}