@logbookfordevs/afk 0.5.2

package/dist/delegates.js

@@ -0,0 +1,220 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { addMcpAgentNames } from "./agents.js";
+import { loadMcpManifest, loadSkillManifest, loadUtilityManifest } from "./manifest.js";
+export function buildSkillCommands(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 || options.includeExternal);
+    return buildSkillSourceCommands(selected, "Shared skills", buildSkillsAgentArgs(options.selectedSkillAgentIds), options.setupScope);
+}
+export function buildMcpCommands(options) {
+    const manifest = loadMcpManifest(options);
+    const agentArgs = buildAddMcpAgentArgs(options.agents, options.yes, options.setupScope);
+    if (options.agents.length > 0 && agentArgs.length === 0) {
+        return [];
+    }
+    return manifest.items
+        .filter((item) => options.selectedMcpIds.length === 0 ? item.default : options.selectedMcpIds.includes(item.id))
+        .map((item) => ({
+        label: item.label,
+        command: "npx",
+        args: [
+            "add-mcp",
+            item.source.replace("${HOME}", options.homeDir),
+            ...item.args,
+            ...(options.setupScope === "global" ? ["-g"] : []),
+            ...agentArgs,
+            ...(options.yes ? ["-y"] : []),
+        ],
+    }));
+}
+export function buildUtilityCommands(options) {
+    const manifest = loadUtilityManifest(options);
+    const selected = options.selectedUtilIds.length > 0
+        ? manifest.items.filter((item) => options.selectedUtilIds.includes(item.id))
+        : manifest.items.filter((item) => item.default);
+    return selected.flatMap((item) => [
+        buildUtilityInstallCommand(item),
+        ...buildUtilityPostInstallCommands(item, options),
+    ]);
+}
+export async function runDelegateCommands(runtime, commands, options) {
+    const failures = [];
+    for (const item of commands) {
+        runtime.io.stdout(`\n${item.label}`);
+        if (item.cwd) {
+            runtime.io.stdout(`(in ${item.cwd})`);
+        }
+        runtime.io.stdout(`$ ${item.command} ${item.args.map(quoteArg).join(" ")}`);
+        if (options.dryRun) {
+            continue;
+        }
+        if (item.cwd) {
+            mkdirSync(item.cwd, { recursive: true });
+        }
+        const result = await runtime.spawn(item.command, item.args, item.cwd ?? options.cwd ?? options.repoDir);
+        if (result.code !== 0) {
+            if (options.continueOnError) {
+                failures.push({ label: item.label, code: result.code });
+                runtime.io.stderr(`Warning: ${item.label} failed with exit code ${result.code}. Continuing.`);
+                continue;
+            }
+            return result.code;
+        }
+    }
+    if (failures.length > 0) {
+        runtime.io.stdout("\nSome delegated commands failed:");
+        for (const failure of failures) {
+            runtime.io.stdout(`- ${failure.label} exited with code ${failure.code}`);
+        }
+    }
+    return 0;
+}
+function buildAddMcpAgentArgs(agents, nonInteractive, scope) {
+    const selected = agents.length > 0 ? agents : nonInteractive ? defaultMcpAgents(scope) : [];
+    const args = [];
+    for (const agent of selected) {
+        if (scope === "project" && agent === "antigravity") {
+            continue;
+        }
+        const addMcpName = addMcpAgentNames[agent];
+        if (addMcpName) {
+            args.push("-a", addMcpName);
+        }
+    }
+    return args;
+}
+function defaultMcpAgents(scope) {
+    return scope === "global"
+        ? ["antigravity", "claude", "codex", "opencode"]
+        : ["claude", "codex", "opencode"];
+}
+function buildUtilityInstallCommand(item) {
+    return {
+        label: `${item.label} / install`,
+        command: item.install.command,
+        args: item.install.args,
+    };
+}
+function buildUtilityPostInstallCommands(item, options) {
+    if (typeof item.postInstall === "object") {
+        return [{
+                label: item.postInstall.label ?? `${item.label} / post-install`,
+                command: item.postInstall.command,
+                args: item.postInstall.args,
+            }];
+    }
+    if (item.postInstall !== "rtk-init") {
+        return [];
+    }
+    const selectedAgents = filterUtilityAgents(options.agents);
+    return selectedAgents.map((agent) => ({
+        label: `RTK / init ${agentLabel(agent)}`,
+        command: "rtk",
+        args: rtkInitArgs(agent, options.setupScope),
+        ...(options.setupScope === "global" && agent === "codex" ? { cwd: join(options.homeDir, ".codex") } : {}),
+    }));
+}
+function defaultUtilityAgents() {
+    return ["antigravity", "claude", "codex", "opencode"];
+}
+function filterUtilityAgents(agents) {
+    if (agents.length === 0) {
+        return defaultUtilityAgents();
+    }
+    return agents.filter((agent) => defaultUtilityAgents().includes(agent));
+}
+function rtkInitArgs(agent, scope) {
+    if (scope === "project") {
+        switch (agent) {
+            case "claude":
+                return ["init"];
+            case "codex":
+                return ["init", "--codex"];
+            case "antigravity":
+                return ["init", "--agent", "antigravity"];
+            case "opencode":
+                return ["init", "--opencode"];
+            case "cursor-local":
+                return ["init"];
+        }
+    }
+    switch (agent) {
+        case "claude":
+            return ["init", "--global"];
+        case "codex":
+            return ["init", "--codex"];
+        case "antigravity":
+            // Antigravity still consumes the global Gemini rules host, so global RTK uses
+            // the Gemini compatibility initializer while project setup uses Antigravity.
+            return ["init", "--global", "--gemini"];
+        case "opencode":
+            return ["init", "--global", "--opencode"];
+        case "cursor-local":
+            return ["init", "--global"];
+    }
+}
+function agentLabel(agent) {
+    switch (agent) {
+        case "claude":
+            return "Claude Code";
+        case "codex":
+            return "Codex";
+        case "antigravity":
+            return "Antigravity";
+        case "opencode":
+            return "OpenCode";
+        case "cursor-local":
+            return "Cursor Local";
+    }
+}
+function buildSkillsAgentArgs(agents) {
+    return agents.flatMap((agent) => ["--agent", agent]);
+}
+function buildSkillSourceCommands(items, labelPrefix, targetArgs, scope) {
+    const bySource = new Map();
+    for (const item of items) {
+        bySource.set(item.source, [...(bySource.get(item.source) ?? []), item]);
+    }
+    return [...bySource.entries()].map(([source, sourceItems]) => ({
+        label: `${labelPrefix} / ${sourceLabel(source)}`,
+        command: "npx",
+        args: [
+            "skills",
+            "add",
+            source,
+            ...(scope === "global" ? ["--global"] : []),
+            "--yes",
+            ...skillSelectionArgs(sourceItems),
+            ...targetArgs,
+        ],
+    }));
+}
+function skillSelectionArgs(items) {
+    const skillIds = items.map((item) => skillIdFromArgs(item.args));
+    if (skillIds.some((id) => !id)) {
+        return [];
+    }
+    return ["--skill", ...skillIds.filter((id) => Boolean(id))];
+}
+function skillIdFromArgs(args) {
+    const index = args.indexOf("--skill");
+    return index >= 0 ? args[index + 1] ?? null : null;
+}
+function sourceLabel(source) {
+    if (source.includes("logbookfordevs/ai-field-kit")) {
+        return "AI Field Kit";
+    }
+    if (source.includes("addyosmani/agent-skills")) {
+        return "Agent Skills";
+    }
+    return source;
+}
+function quoteArg(value) {
+    if (/^[A-Za-z0-9_./:=@-]+$/.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}

package/dist/fs-utils.js

@@ -0,0 +1,120 @@
+import { constants, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, symlinkSync, writeFileSync, copyFileSync, accessSync } from "node:fs";
+import { dirname } from "node:path";
+export const managedMarker = ".ai-field-kit-managed";
+export function pathExists(path) {
+    return existsSync(path);
+}
+export function isFile(path) {
+    try {
+        return lstatSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function isDirectory(path) {
+    try {
+        return lstatSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function isSymlink(path) {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function canExecute(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readText(path) {
+    return readFileSync(path, "utf8");
+}
+export function ensureParent(path) {
+    mkdirSync(dirname(path), { recursive: true });
+}
+export function backupTarget(path, timestamp) {
+    if (isFile(path) && !isSymlink(path)) {
+        return {
+            type: "backup",
+            source: path,
+            target: `${path}.bak.${timestamp}`,
+        };
+    }
+    return null;
+}
+export function applyOperation(operation) {
+    switch (operation.type) {
+        case "mkdir":
+            mkdirSync(operation.path, { recursive: true });
+            return;
+        case "remove":
+            rmSync(operation.path, { recursive: true, force: true });
+            return;
+        case "symlink":
+            ensureParent(operation.target);
+            symlinkSync(operation.source, operation.target);
+            return;
+        case "copy":
+            ensureParent(operation.target);
+            copyFileSync(operation.source, operation.target);
+            return;
+        case "write":
+            ensureParent(operation.path);
+            writeFileSync(operation.path, operation.content);
+            return;
+        case "backup":
+            ensureParent(operation.target);
+            renameSync(operation.source, operation.target);
+            return;
+        case "skip":
+            return;
+    }
+}
+export function formatOperation(operation) {
+    switch (operation.type) {
+        case "mkdir":
+            return `mkdir ${operation.path}`;
+        case "remove":
+            return `remove ${operation.path}`;
+        case "symlink":
+            return `link ${operation.target} -> ${operation.source}`;
+        case "copy":
+            return `copy ${operation.source} -> ${operation.target}`;
+        case "write":
+            return `write ${operation.path}`;
+        case "backup":
+            return `backup ${operation.source} -> ${operation.target}`;
+        case "skip":
+            return `skip ${operation.path} (${operation.reason})`;
+    }
+}
+export function summarizeOperations(operations) {
+    const counts = new Map();
+    for (const operation of operations) {
+        counts.set(operation.type, (counts.get(operation.type) ?? 0) + 1);
+    }
+    const parts = [
+        formatCount("created directories", counts.get("mkdir") ?? 0),
+        formatCount("wrote files", counts.get("write") ?? 0),
+        formatCount("linked files", counts.get("symlink") ?? 0),
+        formatCount("copied files", counts.get("copy") ?? 0),
+        formatCount("backed up files", counts.get("backup") ?? 0),
+        formatCount("removed files", counts.get("remove") ?? 0),
+        formatCount("skipped unchanged or unmanaged files", counts.get("skip") ?? 0),
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join(", ") : "no file changes";
+}
+function formatCount(label, count) {
+    return count > 0 ? `${count} ${label}` : "";
+}

package/dist/hooks.js

@@ -0,0 +1,217 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, isAbsolute, join, resolve } from "node:path";
+import { applyOperation, formatOperation, pathExists, readText, summarizeOperations } from "./fs-utils.js";
+import { loadHookManifest } from "./manifest.js";
+const hookAgents = ["codex", "claude", "cursor-local"];
+export async function syncHooks(runtime, options) {
+    const operations = await planHooksSync(options);
+    if (options.dryRun) {
+        runtime.io.stdout("\nHooks install plan");
+        for (const operation of operations) {
+            runtime.io.stdout(`- ${formatOperation(operation)}`);
+        }
+        return 0;
+    }
+    for (const operation of operations) {
+        applyOperation(operation);
+    }
+    runtime.io.stdout(`\nHooks installed: ${summarizeOperations(operations)}.`);
+    return 0;
+}
+export async function planHooksSync(options) {
+    const manifest = loadHookManifest(options);
+    const selected = selectHookItems(manifest.items, options.selectedHookIds);
+    const operations = [];
+    for (const item of selected) {
+        const sourceContent = await loadHookSource(item.source, options);
+        for (const agent of selectedHookAgents(options.agents, item.agents)) {
+            operations.push(...planAgentHook(agent, options, item, sourceContent));
+        }
+    }
+    return operations;
+}
+function selectHookItems(items, selectedHookIds) {
+    if (selectedHookIds.length > 0) {
+        return items.filter((item) => selectedHookIds.includes(item.id));
+    }
+    return items.filter((item) => item.default);
+}
+function selectedHookAgents(selected, supported) {
+    return selected.filter((agent) => hookAgents.includes(agent) && supported.includes(agent));
+}
+function planAgentHook(agent, options, item, sourceContent) {
+    const scriptPath = agentScriptPath(agent, options, item);
+    const configPath = agentConfigPath(agent, options);
+    const current = pathExists(configPath) ? readText(configPath) : "";
+    const command = buildHookCommand(item, scriptPath, agent);
+    const config = mergeAgentHookConfig(agent, current, command, item);
+    return [
+        {
+            type: "write",
+            path: scriptPath,
+            content: sourceContent,
+        },
+        { type: "write", path: configPath, content: `${JSON.stringify(config, null, 2)}\n` },
+    ];
+}
+function agentScriptPath(agent, options, item) {
+    const base = options.setupScope === "project" ? options.cwd : options.homeDir;
+    const filename = safeHookFilename(item);
+    switch (agent) {
+        case "codex":
+            return join(base, ".codex", "hooks", filename);
+        case "claude":
+            return join(base, ".claude", "hooks", filename);
+        case "cursor-local":
+            return join(base, ".cursor", "hooks", filename);
+    }
+}
+function agentConfigPath(agent, options) {
+    const base = options.setupScope === "project" ? options.cwd : options.homeDir;
+    switch (agent) {
+        case "codex":
+            return join(base, ".codex", "hooks.json");
+        case "claude":
+            return join(base, ".claude", "settings.json");
+        case "cursor-local":
+            return join(base, ".cursor", "hooks.json");
+    }
+}
+function mergeAgentHookConfig(agent, current, command, item) {
+    const config = parseJsonObject(current);
+    const hooks = getOrCreateRecord(config, "hooks");
+    if (agent === "cursor-local") {
+        config.version = typeof config.version === "number" ? config.version : 1;
+        mergeCursorStopHook(hooks, command, item);
+        return config;
+    }
+    mergeCodexClaudeStopHook(hooks, command, item);
+    return config;
+}
+function mergeCodexClaudeStopHook(hooks, command, item) {
+    const entries = getOrCreateArray(hooks, "Stop");
+    const handler = {
+        type: "command",
+        command,
+        statusMessage: "Checking AFK tracking",
+    };
+    upsertMatcherHook(entries, "", handler, command, item);
+}
+function mergeCursorStopHook(hooks, command, item) {
+    const entries = getOrCreateArray(hooks, "stop");
+    const hook = { command };
+    if (entries.some((entry) => isRecord(entry) && entry.command === command)) {
+        return;
+    }
+    const filtered = entries.filter((entry) => !isRecord(entry) || !isManagedHookCommand(entry.command, item));
+    filtered.push(hook);
+    hooks.stop = filtered;
+}
+function upsertMatcherHook(entries, matcher, handler, command, item) {
+    const existingGroup = entries.find((entry) => isRecord(entry) && entry.matcher === matcher);
+    const group = isRecord(existingGroup) ? existingGroup : { matcher, hooks: [] };
+    if (!isRecord(existingGroup)) {
+        entries.push(group);
+    }
+    const hooks = Array.isArray(group.hooks) ? group.hooks : [];
+    const filtered = hooks.filter((hook) => !isRecord(hook) || (!isManagedHookCommand(hook.command, item) && hook.command !== command));
+    filtered.push(handler);
+    group.hooks = filtered;
+}
+function buildHookCommand(item, hookFile, agent) {
+    const args = item.args.map((arg) => replaceHookPlaceholders(arg, hookFile, agent));
+    return [item.command, ...args].map(quoteArg).join(" ");
+}
+function replaceHookPlaceholders(value, hookFile, agent) {
+    return value
+        .replaceAll("${HOOK_FILE}", hookFile)
+        .replaceAll("${AGENT}", agent);
+}
+function safeHookFilename(item) {
+    const sourceName = filenameFromSource(item.source);
+    if (sourceName) {
+        return sourceName;
+    }
+    return `${item.id.replace(/[^a-z0-9._-]+/gi, "-")}.js`;
+}
+function filenameFromSource(source) {
+    try {
+        const parsed = new URL(source);
+        return basename(parsed.pathname);
+    }
+    catch {
+        return basename(source);
+    }
+}
+async function loadHookSource(source, options) {
+    if (/^https?:\/\//.test(source)) {
+        const response = await fetch(source);
+        if (!response.ok) {
+            throw new Error(`Could not fetch hook source ${source}: ${response.status} ${response.statusText}`);
+        }
+        return ensureTrailingNewline(await response.text());
+    }
+    const path = resolveHookSourcePath(source, options);
+    return ensureTrailingNewline(readFileSync(path, "utf8"));
+}
+function resolveHookSourcePath(source, options) {
+    const candidates = [
+        isAbsolute(source) ? source : resolve(options.cwd, source),
+        isAbsolute(source) ? source : resolve(options.repoDir, source),
+    ];
+    for (const candidate of unique(candidates)) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Missing hook source: ${source}`);
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function ensureTrailingNewline(content) {
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+function isManagedHookCommand(value, item) {
+    const filename = safeHookFilename(item);
+    return typeof value === "string" && filename.length > 0 && value.includes(filename);
+}
+function quoteArg(value) {
+    if (/^[A-Za-z0-9_./:=@-]+$/.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function parseJsonObject(content) {
+    if (!content.trim()) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(content);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function getOrCreateRecord(record, key) {
+    const value = record[key];
+    if (isRecord(value)) {
+        return value;
+    }
+    const next = {};
+    record[key] = next;
+    return next;
+}
+function getOrCreateArray(record, key) {
+    const value = record[key];
+    if (Array.isArray(value)) {
+        return value;
+    }
+    const next = [];
+    record[key] = next;
+    return next;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/index.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCli } from "./cli.js";
+const code = await runCli(process.argv.slice(2));
+process.exitCode = code;