@logbookfordevs/afk 0.5.2

package/dist/interactive.js

@@ -0,0 +1,273 @@
+import { checkbox, select } from "@inquirer/prompts";
+import { agentIds, hookAgentIds, skillAgentChoices, skillAgentIds, universalSkillAgentLabels } from "./agents.js";
+import { loadHookManifest, loadMcpManifest, loadSkillManifest, loadUtilityManifest } from "./manifest.js";
+import { DEFAULT_CHECKED, afkCheckboxTheme, afkSelectTheme, defaultCheckedDetail, renderPromptStep, resetPromptSteps } from "./prompt-ui.js";
+const setupAreaChoices = [
+    {
+        name: "Rules",
+        value: "rules",
+        checked: DEFAULT_CHECKED,
+        description: "Sync AFK global rules into supported rule hosts.",
+    },
+    {
+        name: "Skills",
+        value: "skills",
+        checked: DEFAULT_CHECKED,
+        description: "Delegate AFK and recommended skill installs to the skills CLI.",
+    },
+    {
+        name: "MCPs",
+        value: "mcps",
+        checked: DEFAULT_CHECKED,
+        description: "Delegate recommended MCP installs to add-mcp.",
+    },
+    {
+        name: "Utils",
+        value: "utils",
+        checked: DEFAULT_CHECKED,
+        description: "Install optional developer utilities AFK recommends.",
+    },
+    {
+        name: "Hooks",
+        value: "hooks",
+        checked: DEFAULT_CHECKED,
+        description: "Merge AFK lifecycle hooks into supported agent hook configs.",
+    },
+];
+export async function selectSetup(options) {
+    if (options.yes) {
+        return normalizeSetupSelection({
+            areas: setupAreaChoices.map((choice) => choice.value),
+            agents: options.agents,
+            hookAgents: options.agents,
+            setupScope: options.setupScope,
+            skillIds: loadSkillManifest(options).items.map((item) => item.id),
+            skillAgents: options.selectedSkillAgentIds,
+            mcpIds: loadMcpManifest(options).items.map((item) => item.id),
+            utilIds: loadUtilityManifest(options).items.map((item) => item.id),
+            hookIds: loadHookManifest(options).items.map((item) => item.id),
+        });
+    }
+    resetPromptSteps();
+    const setupScope = options.scopeExplicit ? options.setupScope : await selectSetupScope(options.cwd);
+    const areas = await selectCheckbox("Choose what AFK should prepare", setupAreaChoices);
+    const utilIds = areas.includes("utils") ? await selectUtils(options) : [];
+    const needsAgents = areas.some((area) => area === "rules" || area === "mcps") || utilIds.includes("rtk");
+    const agents = needsAgents ? await selectAgents(options.agents) : options.agents;
+    const skillIds = areas.includes("skills") ? await selectSkills(options) : [];
+    const skillAgents = skillIds.length > 0 ? await selectSkillAgents(options) : [];
+    const mcpIds = areas.includes("mcps") ? await selectMcps(options) : [];
+    const hookIds = areas.includes("hooks") ? await selectHooks(options) : [];
+    const hookAgents = hookIds.length > 0 ? await selectHookAgents(options.agents) : options.agents;
+    return normalizeSetupSelection({
+        areas,
+        agents,
+        hookAgents,
+        setupScope,
+        skillIds,
+        skillAgents,
+        mcpIds,
+        utilIds,
+        hookIds,
+    });
+}
+export async function selectRulesSync(options) {
+    if (options.yes) {
+        return { agents: options.agents };
+    }
+    resetPromptSteps();
+    return { agents: await selectAgents(options.agents) };
+}
+export async function selectSkillsInstall(options) {
+    if (options.yes) {
+        return {
+            skillIds: loadSkillManifest(options).items.map((item) => item.id),
+            skillAgents: options.selectedSkillAgentIds,
+        };
+    }
+    resetPromptSteps();
+    const skillIds = await selectSkills(options);
+    return {
+        skillIds,
+        skillAgents: skillIds.length > 0 ? await selectSkillAgents(options) : [],
+    };
+}
+export async function selectMcpsInstall(options) {
+    if (options.yes) {
+        return {
+            agents: options.agents,
+            mcpIds: loadMcpManifest(options).items.map((item) => item.id),
+        };
+    }
+    resetPromptSteps();
+    return {
+        agents: await selectAgents(options.agents),
+        mcpIds: await selectMcps(options),
+    };
+}
+export async function selectUtilsInstall(options) {
+    if (options.yes) {
+        return {
+            agents: options.agents,
+            utilIds: loadUtilityManifest(options).items.map((item) => item.id),
+        };
+    }
+    resetPromptSteps();
+    const utilIds = await selectUtils(options);
+    const agents = utilIds.includes("rtk") ? await selectAgents(options.agents) : options.agents;
+    return { agents, utilIds };
+}
+export async function selectHooksInstall(options) {
+    if (options.yes) {
+        return {
+            agents: options.agents.filter((agent) => hookAgentIds.includes(agent)),
+            hookIds: loadHookManifest(options).items.map((item) => item.id),
+        };
+    }
+    resetPromptSteps();
+    return {
+        agents: await selectHookAgents(options.agents),
+        hookIds: await selectHooks(options),
+    };
+}
+export function normalizeSetupSelection(selection) {
+    return {
+        ...selection,
+        hookAgents: selection.hookAgents.filter((agent) => hookAgentIds.includes(agent)),
+        skillAgents: selection.skillAgents.filter((agent) => skillAgentIds.includes(agent)),
+        areas: selection.areas.filter((area) => {
+            if (area === "skills") {
+                return selection.skillIds.length > 0;
+            }
+            if (area === "mcps") {
+                return selection.mcpIds.length > 0;
+            }
+            if (area === "utils") {
+                return selection.utilIds.length > 0;
+            }
+            if (area === "hooks") {
+                return selection.hookIds.length > 0 && selection.hookAgents.length > 0;
+            }
+            return true;
+        }),
+    };
+}
+async function selectSetupScope(cwd) {
+    console.log(renderPromptStep("Scope", "Choose whether AFK writes global config or project-local files."));
+    return select({
+        message: "Where should AFK set things up?",
+        choices: [
+            {
+                name: "Global field kit",
+                value: "global",
+                description: "Use across all projects on this machine.",
+            },
+            {
+                name: "This project only",
+                value: "project",
+                description: `Write config into ${cwd} and keep it repo-scoped.`,
+            },
+        ],
+        default: "global",
+        instructions: {
+            navigation: "Use arrow keys to move.",
+            pager: "Use arrow keys to reveal more choices.",
+        },
+        theme: afkSelectTheme,
+    });
+}
+async function selectAgents(preselected) {
+    return selectAgentChoices("Choose agent targets", agentIds, preselected);
+}
+async function selectHookAgents(preselected) {
+    return selectAgentChoices("Choose hook targets", hookAgentIds, preselected);
+}
+async function selectAgentChoices(message, choices, preselected) {
+    const supportedPreselected = preselected.filter((agent) => choices.includes(agent));
+    if (supportedPreselected.length > 0) {
+        return supportedPreselected;
+    }
+    return selectCheckbox(message, choices.map((agent) => {
+        return {
+            name: agent,
+            value: agent,
+            checked: DEFAULT_CHECKED,
+        };
+    }));
+}
+async function selectSkills(options) {
+    const manifest = loadSkillManifest(options);
+    return selectCheckbox("Choose skills to install", manifest.items.map((item) => ({
+        name: item.label,
+        value: item.id,
+        checked: DEFAULT_CHECKED,
+        description: item.args.join(" "),
+    })));
+}
+async function selectSkillAgents(options) {
+    console.log(renderPromptStep("Universal skills", ".agents/skills is always included."));
+    for (const line of compactInlineList(universalSkillAgentLabels, 88)) {
+        console.log(`  ${line}`);
+    }
+    return selectCheckbox("Choose additional skill agent links", skillAgentChoices.map((agent) => ({
+        name: agent.label,
+        value: agent.id,
+        checked: options.selectedSkillAgentIds.includes(agent.id),
+        description: agent.path,
+    })));
+}
+function compactInlineList(values, maxLineLength) {
+    const lines = [];
+    let current = "";
+    for (const value of values) {
+        const next = current ? `${current}, ${value}` : value;
+        if (current && next.length > maxLineLength) {
+            lines.push(current);
+            current = value;
+            continue;
+        }
+        current = next;
+    }
+    if (current) {
+        lines.push(current);
+    }
+    return lines;
+}
+async function selectMcps(options) {
+    const manifest = loadMcpManifest(options);
+    return selectCheckbox("Choose MCPs to install", manifest.items.map((item) => ({
+        name: item.label,
+        value: item.id,
+        checked: DEFAULT_CHECKED,
+        description: item.source,
+    })));
+}
+async function selectUtils(options) {
+    const manifest = loadUtilityManifest(options);
+    return selectCheckbox("Choose utilities to install", manifest.items.map((item) => ({
+        name: item.label,
+        value: item.id,
+        checked: DEFAULT_CHECKED,
+        description: item.description,
+    })));
+}
+async function selectHooks(options) {
+    const manifest = loadHookManifest(options);
+    return selectCheckbox("Choose hooks to install", manifest.items.map((item) => ({
+        name: item.label,
+        value: item.id,
+        checked: DEFAULT_CHECKED,
+        description: item.description,
+    })));
+}
+async function selectCheckbox(message, choices) {
+    console.log(renderPromptStep(message, defaultCheckedDetail));
+    return checkbox({
+        message,
+        choices,
+        required: false,
+        pageSize: 12,
+        instructions: "Use space to toggle, enter to continue.",
+        theme: afkCheckboxTheme,
+    });
+}

package/dist/manifest-configure.js

@@ -0,0 +1,300 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { checkbox, confirm, input } from "@inquirer/prompts";
+import { localManifestDir } from "./manifest.js";
+import { DEFAULT_CHECKED, afkCheckboxTheme, afkPromptTheme, defaultCheckedDetail, renderPromptStep, resetPromptSteps } from "./prompt-ui.js";
+const manifestAreaChoices = [
+    { name: "Rules", value: "rules", checked: DEFAULT_CHECKED, description: "Point rules sync at one AGENTS.md source." },
+    { name: "Skills", value: "skills", checked: DEFAULT_CHECKED, description: "List skills delegated to the skills CLI." },
+    { name: "MCPs", value: "mcps", checked: DEFAULT_CHECKED, description: "List MCPs delegated to add-mcp." },
+    { name: "Utils", value: "utils", checked: DEFAULT_CHECKED, description: "List utility install scripts." },
+    { name: "Hooks", value: "hooks", checked: DEFAULT_CHECKED, description: "List lifecycle hooks AFK can merge into agent configs." },
+];
+export async function runManifestConfigure(runtime, options) {
+    const outputDir = options.manifestConfigureLocal ? join(options.cwd, "afk", "manifests") : localManifestDir(options.homeDir);
+    const existing = options.manifestConfigureFromCurrent ? readExistingManifests(outputDir) : {};
+    resetPromptSteps();
+    runtime.io.stdout("\nAFK manifests configure");
+    runtime.io.stdout(`Writing to: ${outputDir}`);
+    runtime.io.stdout(renderPromptStep("Manifest files", defaultCheckedDetail));
+    const areas = await checkbox({
+        message: "Choose manifests to configure",
+        choices: manifestAreaChoices,
+        required: false,
+        pageSize: 8,
+        instructions: "Use space to toggle, enter to continue.",
+        theme: afkCheckboxTheme,
+    });
+    if (areas.length === 0) {
+        runtime.io.stdout("\nNothing selected. No manifests changed.");
+        return 0;
+    }
+    const drafts = {};
+    for (const area of areas) {
+        runtime.io.stdout(renderPromptStep(areaTitle(area), areaDescription(area)));
+        drafts[`${area}.json`] = await configureArea(area, existing);
+    }
+    runtime.io.stdout("\nManifest preview");
+    for (const [filename, content] of Object.entries(drafts)) {
+        runtime.io.stdout(`\n--- ${filename} ---\n${content.trimEnd()}`);
+    }
+    if (options.dryRun) {
+        runtime.io.stdout("\nDry run complete. No manifests written.");
+        return 0;
+    }
+    runtime.io.stdout(renderPromptStep("Write manifests", "Review the preview above, then confirm whether AFK should write the files."));
+    const shouldWrite = await askConfirm(`Write ${areas.length} manifest file(s)?`, true);
+    if (!shouldWrite) {
+        runtime.io.stdout("\nCancelled. No manifests written.");
+        return 0;
+    }
+    mkdirSync(outputDir, { recursive: true });
+    for (const [filename, content] of Object.entries(drafts)) {
+        writeFileSync(join(outputDir, filename), content);
+    }
+    runtime.io.stdout(`\nWrote ${areas.length} manifest file(s) to ${outputDir}.`);
+    return 0;
+}
+async function configureArea(area, existing) {
+    switch (area) {
+        case "rules":
+            return configureRules(existing.rules);
+        case "skills":
+            return configureSkills(existing.skills);
+        case "mcps":
+            return configureMcps(existing.mcps);
+        case "utils":
+            return configureUtils(existing.utils);
+        case "hooks":
+            return configureHooks(existing.hooks);
+    }
+}
+async function configureRules(existing) {
+    const url = await askInput({
+        message: "Rules raw URL or local path",
+        default: existing?.url || "",
+        required: true,
+    });
+    return json({
+        version: 1,
+        source: inferSource(url),
+        url,
+    });
+}
+async function configureSkills(existing) {
+    const items = [...(existing?.items ?? [])];
+    let defaultSource = existing?.defaultSource ?? "";
+    while (true) {
+        const source = await askInput({ message: "Skill source repo URL (blank to finish)" });
+        if (!source.trim()) {
+            break;
+        }
+        defaultSource ||= source;
+        const skill = await askInput({ message: "Specific skill id/name (optional; blank installs the whole source)" });
+        const idSeed = skill.trim() ? skill : source;
+        const id = uniqueId(inferId(idSeed), items.map((item) => item.id));
+        const label = await askInput({ message: "Skill label", default: inferLabel(id) });
+        const isDefault = await askConfirm("Selected by default?", true);
+        const autoInvocation = await askConfirm("Allow automatic model invocation?", true);
+        items.push({
+            id,
+            label,
+            source,
+            args: skill.trim() ? ["--skill", skill.trim()] : [],
+            default: isDefault,
+            autoInvocation,
+        });
+    }
+    return json({
+        version: 1,
+        defaultSource,
+        items,
+    });
+}
+async function configureMcps(existing) {
+    const items = [...(existing?.items ?? [])];
+    while (true) {
+        const source = await askInput({ message: "MCP source or command (blank to finish)" });
+        if (!source.trim()) {
+            break;
+        }
+        const id = uniqueId(inferId(source), items.map((item) => item.id));
+        const label = await askInput({ message: "MCP label", default: inferLabel(id) });
+        const name = await askInput({ message: "add-mcp --name value", default: id });
+        const extraArgs = await askInput({ message: "Extra add-mcp args (optional)" });
+        const isDefault = await askConfirm("Selected by default?", true);
+        items.push({
+            id,
+            label,
+            source,
+            args: [...(name ? ["--name", name] : []), ...splitArgs(extraArgs)],
+            default: isDefault,
+        });
+    }
+    return json({ version: 1, items });
+}
+async function configureUtils(existing) {
+    const items = [...(existing?.items ?? [])];
+    while (true) {
+        const installLine = await askInput({ message: "Utility install command (blank to finish)" });
+        if (!installLine.trim()) {
+            break;
+        }
+        const id = uniqueId(inferId(installLine), items.map((item) => item.id));
+        const label = await askInput({ message: "Utility label", default: inferLabel(id) });
+        const description = await askInput({ message: "Utility description", default: `${label} install script.` });
+        const postInstallLine = await askInput({ message: "Post-install command (optional)" });
+        const isDefault = await askConfirm("Selected by default?", true);
+        items.push({
+            id,
+            label,
+            description,
+            install: { command: "sh", args: ["-c", installLine] },
+            ...(postInstallLine.trim()
+                ? { postInstall: { command: "sh", args: ["-c", postInstallLine.trim()] } }
+                : {}),
+            default: isDefault,
+        });
+    }
+    return json({ version: 1, items });
+}
+async function configureHooks(existing) {
+    const items = [...(existing?.items ?? [])];
+    const shouldAddDefault = items.length === 0
+        ? await askConfirm("Add AFK execution tracking stop check?", true)
+        : false;
+    if (shouldAddDefault) {
+        items.push({
+            id: "afk-execution-tracking-stop-check",
+            label: "AFK / Execution Tracking Stop Check",
+            description: "Nudge the agent once before final handoff when implementation files changed without tracking, implementation notes, or ADR reconciliation.",
+            source: "https://raw.githubusercontent.com/logbookfordevs/ai-field-kit/main/hooks/afk-execution-tracking-stop-check.js",
+            command: "node",
+            args: ["${HOOK_FILE}", "--agent", "${AGENT}"],
+            events: ["stop"],
+            agents: ["codex", "claude", "cursor-local"],
+            default: true,
+        });
+    }
+    return json({ version: 1, items });
+}
+async function askInput(config) {
+    return input({
+        ...config,
+        theme: afkPromptTheme,
+    });
+}
+async function askConfirm(message, defaultValue) {
+    return confirm({
+        message,
+        default: defaultValue,
+        theme: afkPromptTheme,
+    });
+}
+function areaTitle(area) {
+    switch (area) {
+        case "rules":
+            return "Rules manifest";
+        case "skills":
+            return "Skills manifest";
+        case "mcps":
+            return "MCP manifest";
+        case "utils":
+            return "Utils manifest";
+        case "hooks":
+            return "Hooks manifest";
+    }
+}
+function areaDescription(area) {
+    switch (area) {
+        case "rules":
+            return "Point rules sync at a raw AGENTS.md source.";
+        case "skills":
+            return "List skills delegated to the official skills CLI.";
+        case "mcps":
+            return "List MCPs delegated to add-mcp.";
+        case "utils":
+            return "List utility install scripts and optional post-install commands.";
+        case "hooks":
+            return "List lifecycle hooks AFK can merge into agent hook configs.";
+    }
+}
+export function inferId(value) {
+    const candidate = filenameStem(value) || value;
+    const withoutGit = candidate.replace(/\.git$/i, "");
+    const normalized = withoutGit
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return normalized || "item";
+}
+export function inferLabel(value) {
+    const titled = value
+        .replace(/\.(md|json|toml|yaml|yml)$/i, "")
+        .replace(/^afk-/, "AFK / ")
+        .replace(/[-_]+/g, " ")
+        .replace(/\b\w/g, (char) => char.toUpperCase())
+        .trim();
+    return titled.replace(/\b(Api|Mcp|Url|Afk|Cli|Rtk|Pr)\b/g, (match) => match.toUpperCase());
+}
+function filenameStem(value) {
+    try {
+        const parsed = new URL(value);
+        const last = basename(parsed.pathname);
+        return last.replace(/\.[^.]+$/, "");
+    }
+    catch {
+        const last = basename(value.trim());
+        return last.replace(/\.[^.]+$/, "");
+    }
+}
+function inferSource(value) {
+    return /^https:\/\/(raw\.githubusercontent\.com|github\.com)\//.test(value) ? "github" : "local";
+}
+function uniqueId(id, existingIds) {
+    if (!existingIds.includes(id)) {
+        return id;
+    }
+    let index = 2;
+    while (existingIds.includes(`${id}-${index}`)) {
+        index += 1;
+    }
+    return `${id}-${index}`;
+}
+function splitArgs(value) {
+    return value.split(/\s+/).map((item) => item.trim()).filter(Boolean);
+}
+function readExistingManifests(outputDir) {
+    const existing = {};
+    const skills = readJsonIfExists(join(outputDir, "skills.json"));
+    const mcps = readJsonIfExists(join(outputDir, "mcps.json"));
+    const rules = readJsonIfExists(join(outputDir, "rules.json"));
+    const utils = readJsonIfExists(join(outputDir, "utils.json"));
+    const hooks = readJsonIfExists(join(outputDir, "hooks.json"));
+    if (skills) {
+        existing.skills = skills;
+    }
+    if (mcps) {
+        existing.mcps = mcps;
+    }
+    if (rules) {
+        existing.rules = rules;
+    }
+    if (utils) {
+        existing.utils = utils;
+    }
+    if (hooks) {
+        existing.hooks = hooks;
+    }
+    return existing;
+}
+function readJsonIfExists(path) {
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function json(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}