@interf/compiler 0.1.8

package/dist/lib/agents.js

@@ -0,0 +1,760 @@
+import { appendFileSync, existsSync, mkdirSync, cpSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { SKILLS_DIR } from "./config.js";
+import { loadUserConfig } from "./user-config.js";
+import chalk from "chalk";
+const SHOW_AGENT_TOOL_EVENTS = process.env.INTERF_DEBUG_AGENT_TOOLS === "1";
+const AGENTS = [
+    {
+        name: "claude-code",
+        displayName: "Claude Code",
+        skillsDir: join(homedir(), ".claude", "skills"),
+        command: "claude",
+    },
+    {
+        name: "codex",
+        displayName: "Codex",
+        skillsDir: join(homedir(), ".codex", "skills"),
+        command: "codex",
+    },
+    {
+        name: "cursor",
+        displayName: "Cursor",
+        skillsDir: join(homedir(), ".cursor", "skills"),
+        command: "cursor",
+    },
+];
+const CODEX_NOISE_PATTERNS = [
+    /codex_core_skills::loader: failed to stat skills entry .*\/(interf-[^ ]+|knowledge-base\/[^ ]+|interface\/[^ ]+) \(symlink\): No such file or directory/,
+    /codex_core::codex: failed to load skill .*\/gstack\/SKILL\.md: invalid description: exceeds maximum length of 1024 characters/,
+];
+const SKILLS_LIST_ARGS = ["-y", "skills", "list", "-g", "--json"];
+const VISIBLE_STATUS_PREFIXES = ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"];
+let installedSkillsCache = null;
+const autoRefreshAttemptedAgents = new Set();
+const successfulPreflightAgents = new Set();
+export function detectAgents() {
+    return AGENTS.filter((a) => {
+        const dir = join(homedir(), `.${a.name === "claude-code" ? "claude" : a.name}`);
+        return existsSync(dir);
+    });
+}
+export function commandExists(command) {
+    try {
+        execFileSync("which", [command], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function supportsAutomatedRuns(agent) {
+    return agent.name === "claude-code" || agent.name === "codex";
+}
+export function resolveAgent() {
+    const config = loadUserConfig();
+    if (config) {
+        const configured = AGENTS.find((a) => a.command === config.agentCommand) ??
+            AGENTS.find((a) => a.name === config.agent) ??
+            AGENTS.find((a) => a.displayName === config.agent);
+        if (!configured) {
+            return {
+                agent: null,
+                error: `Configured agent "${config.agent}" is not supported by this Interf build. Run \`interf init\` to choose a supported agent.`,
+            };
+        }
+        if (!commandExists(configured.command)) {
+            return {
+                agent: null,
+                error: `Configured agent "${configured.displayName}" is not available in PATH. Run \`interf init\` to reconfigure.`,
+            };
+        }
+        if (!supportsAutomatedRuns(configured)) {
+            return {
+                agent: null,
+                error: `Configured agent "${configured.displayName}" is detected, but this Interf build can only automate Claude Code or Codex. Run \`interf init\` and choose one of those agents.`,
+            };
+        }
+        return { agent: configured };
+    }
+    const detected = detectAgents().filter((a) => commandExists(a.command) && supportsAutomatedRuns(a));
+    if (detected.length === 0) {
+        return {
+            agent: null,
+            error: "No coding agent detected. Install Claude Code or Codex.",
+        };
+    }
+    if (detected.length > 1) {
+        return {
+            agent: null,
+            error: "Multiple coding agents detected but no default is configured. Run `interf init` to choose which agent compile commands should use.",
+        };
+    }
+    return { agent: detected[0] };
+}
+export function installSkills(agents) {
+    const targets = agents ?? detectAgents();
+    const results = [];
+    if (!existsSync(SKILLS_DIR))
+        return results;
+    installedSkillsCache = null;
+    const skills = listBundledInterfSkills();
+    for (const skill of skills) {
+        for (const agent of targets) {
+            try {
+                const target = join(agent.skillsDir, skill);
+                mkdirSync(dirname(target), { recursive: true });
+                cpSync(join(SKILLS_DIR, skill), target, { recursive: true });
+                results.push({ agent: agent.displayName, skill, success: true });
+            }
+            catch {
+                results.push({ agent: agent.displayName, skill, success: false });
+            }
+        }
+    }
+    return results;
+}
+export function refreshInterfSkills(agent) {
+    installedSkillsCache = null;
+    try {
+        execFileSync("npx", ["-y", "skills", "add", "--global", "--yes", SKILLS_DIR], { stdio: "ignore" });
+    }
+    catch {
+        // Ignore and fall back to direct installation below.
+    }
+    installSkills([agent]);
+    installedSkillsCache = null;
+    const health = inspectInterfSkills(agent);
+    return health.missing.length === 0 && health.stale.length === 0 && health.wrongAgent.length === 0;
+}
+export function inspectInterfSkills(agent) {
+    const health = { missing: [], stale: [], wrongAgent: [] };
+    const bundledSkills = listBundledInterfSkills();
+    if (bundledSkills.length === 0)
+        return health;
+    const installed = listInstalledSkills();
+    for (const skillName of bundledSkills) {
+        const localStatus = getAgentLocalSkillStatus(agent, skillName);
+        if (localStatus.current) {
+            continue;
+        }
+        if (localStatus.present) {
+            health.stale.push(skillName);
+            continue;
+        }
+        if (installed) {
+            const entry = installed.find((item) => item.name === skillName);
+            if (!entry) {
+                health.missing.push(skillName);
+                continue;
+            }
+            const agents = entry.agents ?? [];
+            if (agents.length > 0 && !agents.includes(agent.displayName)) {
+                health.wrongAgent.push(skillName);
+                continue;
+            }
+            if (!entry.path || !bundledSkillMatchesInstalledPath(skillName, join(entry.path, "SKILL.md"))) {
+                health.stale.push(skillName);
+            }
+            continue;
+        }
+        const candidatePaths = installedSkillCandidatePaths(agent, skillName);
+        if (candidatePaths.length === 0) {
+            health.missing.push(skillName);
+            continue;
+        }
+        const hasCurrentCopy = candidatePaths.some((path) => bundledSkillMatchesInstalledPath(skillName, path));
+        if (!hasCurrentCopy) {
+            health.stale.push(skillName);
+        }
+    }
+    return health;
+}
+function appendAgentEventLog(eventLogPath, event) {
+    if (!eventLogPath)
+        return;
+    mkdirSync(dirname(eventLogPath), { recursive: true });
+    appendFileSync(eventLogPath, `${JSON.stringify({
+        timestamp: new Date().toISOString(),
+        ...event,
+    })}\n`);
+}
+function appendAgentStatusLog(statusLogPath, text) {
+    if (!statusLogPath)
+        return;
+    mkdirSync(dirname(statusLogPath), { recursive: true });
+    appendFileSync(statusLogPath, `${new Date().toISOString()} ${text}\n`);
+}
+function emitVisibleAgentText(text, statusLogPath, lastVisibleText) {
+    if (lastVisibleText?.terminated) {
+        return false;
+    }
+    let displayed = false;
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => shouldDisplayAgentText(line));
+    for (const line of lines) {
+        if (lastVisibleText && lastVisibleText.current === line) {
+            continue;
+        }
+        console.log(chalk.dim(`  ${line}`));
+        appendAgentStatusLog(statusLogPath, line);
+        if (lastVisibleText) {
+            lastVisibleText.current = line;
+            if (isTerminalVisibleStatus(line)) {
+                lastVisibleText.terminated = true;
+            }
+        }
+        displayed = true;
+    }
+    return displayed;
+}
+export function spawnAgent(agent, dirPath, prompt, options = {}) {
+    const requiredSkill = extractRequiredSkill(prompt);
+    const skillError = ensureRequiredSkill(agent, requiredSkill);
+    if (skillError) {
+        console.log(chalk.red(`  ${skillError}`));
+        return Promise.resolve(1);
+    }
+    return new Promise((resolve, reject) => {
+        const args = buildAgentArgs(agent, prompt, options.executionProfile);
+        appendAgentEventLog(options.eventLogPath, {
+            type: "spawn",
+            command: agent.command,
+            args,
+            cwd: dirPath,
+        });
+        const launchLine = `Launching ${agent.displayName}...`;
+        console.log(chalk.dim(`  ${launchLine}`));
+        appendAgentStatusLog(options.statusLogPath, launchLine);
+        const proc = spawn(agent.command, args, {
+            cwd: dirPath,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const timeoutMs = options.executionProfile?.timeoutMs ?? null;
+        // Parse streaming NDJSON events and show progress
+        let buffer = "";
+        let stderrBuffer = "";
+        let lastRawOutputAt = Date.now();
+        let lastVisibleOutputAt = Date.now();
+        let lastHeartbeatAt = 0;
+        let sawRawOutput = false;
+        let sawVisibleEvent = false;
+        let timedOut = false;
+        let completionSatisfied = false;
+        let failureStatus = null;
+        const lastVisibleText = { current: null };
+        const heartbeat = setInterval(() => {
+            const now = Date.now();
+            const minQuietMs = sawVisibleEvent ? 15000 : 8000;
+            const minHeartbeatGapMs = sawVisibleEvent ? 30000 : 12000;
+            if (now - lastVisibleOutputAt < minQuietMs)
+                return;
+            if (now - lastHeartbeatAt < minHeartbeatGapMs)
+                return;
+            lastHeartbeatAt = now;
+            const seconds = Math.floor((now - lastVisibleOutputAt) / 1000);
+            const label = sawVisibleEvent
+                ? `${agent.displayName} is still running... (${seconds}s since last output)`
+                : sawRawOutput
+                    ? `${agent.displayName} is active, but has not emitted visible progress yet... (${seconds}s)`
+                    : `${agent.displayName} started, but has not emitted visible progress yet... (${seconds}s)`;
+            console.log(chalk.dim(`  ${label}`));
+        }, 5000);
+        const forwardSignal = () => {
+            proc.kill("SIGINT");
+        };
+        const timeout = typeof timeoutMs === "number" && timeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                appendAgentEventLog(options.eventLogPath, {
+                    type: "timeout",
+                    timeout_ms: timeoutMs,
+                });
+                console.log(chalk.red(`  ${agent.displayName} timed out after ${Math.round(timeoutMs / 1000)}s.`));
+                proc.kill("SIGINT");
+            }, timeoutMs)
+            : null;
+        const completionPoll = options.completionCheck
+            ? setInterval(() => {
+                if (timedOut || completionSatisfied)
+                    return;
+                try {
+                    if (!options.completionCheck?.())
+                        return;
+                    completionSatisfied = true;
+                    appendAgentEventLog(options.eventLogPath, {
+                        type: "completion-check-satisfied",
+                    });
+                    proc.kill("SIGINT");
+                }
+                catch {
+                    // Ignore completion check failures and let the agent continue.
+                }
+            }, 1000)
+            : null;
+        process.once("SIGINT", forwardSignal);
+        proc.stdout?.on("data", (chunk) => {
+            lastRawOutputAt = Date.now();
+            sawRawOutput = true;
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                appendAgentEventLog(options.eventLogPath, {
+                    type: "stdout",
+                    line,
+                });
+                try {
+                    const event = JSON.parse(line);
+                    failureStatus ||= extractAgentFailureStatus(event);
+                    if (displayEvent(event, options.statusLogPath, lastVisibleText)) {
+                        sawVisibleEvent = true;
+                        lastVisibleOutputAt = Date.now();
+                    }
+                }
+                catch {
+                    if (emitVisibleAgentText(line, options.statusLogPath, lastVisibleText)) {
+                        sawVisibleEvent = true;
+                        lastVisibleOutputAt = Date.now();
+                    }
+                }
+            }
+        });
+        proc.stderr?.on("data", (chunk) => {
+            stderrBuffer += chunk.toString();
+            const lines = stderrBuffer.split("\n");
+            stderrBuffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                appendAgentEventLog(options.eventLogPath, {
+                    type: "stderr",
+                    line,
+                });
+                if (CODEX_NOISE_PATTERNS.some((pattern) => pattern.test(line)))
+                    continue;
+                lastRawOutputAt = Date.now();
+                sawRawOutput = true;
+                lastVisibleOutputAt = Date.now();
+                process.stderr.write(line + "\n");
+                sawVisibleEvent = true;
+            }
+        });
+        proc.on("close", (code) => {
+            clearInterval(heartbeat);
+            if (timeout)
+                clearTimeout(timeout);
+            if (completionPoll)
+                clearInterval(completionPoll);
+            process.removeListener("SIGINT", forwardSignal);
+            const finalCode = timedOut ? 124 : completionSatisfied ? 0 : failureStatus ? 1 : (code ?? 0);
+            appendAgentEventLog(options.eventLogPath, {
+                type: "close",
+                code: finalCode,
+                failure_status: failureStatus,
+            });
+            resolve(finalCode);
+        });
+        proc.on("error", () => {
+            clearInterval(heartbeat);
+            if (timeout)
+                clearTimeout(timeout);
+            if (completionPoll)
+                clearInterval(completionPoll);
+            process.removeListener("SIGINT", forwardSignal);
+            appendAgentEventLog(options.eventLogPath, {
+                type: "error",
+                message: `Failed to start ${agent.displayName}`,
+            });
+            console.log(chalk.red(`  Failed to start ${agent.displayName}.`));
+            resolve(1);
+        });
+    });
+}
+export function buildAgentArgs(agent, prompt, executionProfile = {}) {
+    if (agent.name === "claude-code") {
+        const args = [
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--allowedTools",
+            "Read,Write,Edit,Bash,Grep,Glob,Agent",
+        ];
+        if (executionProfile.model) {
+            args.push("--model", executionProfile.model);
+        }
+        if (executionProfile.effort) {
+            args.push("--effort", executionProfile.effort);
+        }
+        return args;
+    }
+    if (agent.name === "codex") {
+        const args = [
+            "exec",
+            "--json",
+            "-s",
+            "workspace-write",
+            "--skip-git-repo-check",
+        ];
+        if (executionProfile.model) {
+            args.push("--model", executionProfile.model);
+        }
+        if (executionProfile.profile) {
+            args.push("--profile", executionProfile.profile);
+        }
+        if (executionProfile.effort) {
+            args.push("-c", `model_reasoning_effort=${JSON.stringify(executionProfile.effort)}`);
+        }
+        args.push(prompt);
+        return args;
+    }
+    throw new Error(`Agent "${agent.displayName}" is not yet supported for automated compile runs.`);
+}
+export function buildAgentPreflightPrompt() {
+    return [
+        "Interf doctor preflight.",
+        'Reply with exactly one line: "DONE: Interf doctor ok".',
+        "Do not use tools.",
+        "Do not read files.",
+        "Do not write files.",
+    ].join(" ");
+}
+export function runAgentPreflight(agent, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 30000;
+    const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+    const dirPath = mkdtempSync(join(tmpdir(), "interf-doctor-"));
+    try {
+        const result = spawnSyncImpl(agent.command, buildAgentArgs(agent, buildAgentPreflightPrompt()), {
+            cwd: dirPath,
+            encoding: "utf8",
+            timeout: timeoutMs,
+        });
+        const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";
+        const stderr = sanitizeAgentStderr(typeof result.stderr === "string" ? result.stderr : "");
+        const timedOut = result.error?.name === "Error" && result.error.message.includes("timed out");
+        if (result.error) {
+            return {
+                ok: false,
+                code: typeof result.status === "number" ? result.status : null,
+                timedOut,
+                stdout,
+                stderr,
+                error: result.error.message,
+            };
+        }
+        return {
+            ok: result.status === 0,
+            code: typeof result.status === "number" ? result.status : null,
+            timedOut: false,
+            stdout,
+            stderr,
+            error: result.status === 0 ? null : `Exited with code ${result.status ?? "unknown"}`,
+        };
+    }
+    finally {
+        rmSync(dirPath, { recursive: true, force: true });
+    }
+}
+export function ensureAgentAutomatedRunReady(agent, options = {}) {
+    if (!options.force && successfulPreflightAgents.has(agent.name)) {
+        return { ok: true };
+    }
+    const runPreflight = options.runPreflight ?? runAgentPreflight;
+    const result = runPreflight(agent);
+    if (!result.ok) {
+        const details = [result.error, result.stderr].filter(Boolean).join(" ");
+        return {
+            ok: false,
+            error: `${agent.displayName} failed Interf executor preflight. Run \`interf doctor --live\` for details.${details ? ` ${details}` : ""}`,
+        };
+    }
+    successfulPreflightAgents.add(agent.name);
+    return { ok: true };
+}
+function displayEvent(event, statusLogPath, lastVisibleText) {
+    const type = event.type;
+    let displayed = false;
+    // Tool use — show tool name + brief input
+    if (type === "tool_use" && SHOW_AGENT_TOOL_EVENTS) {
+        const name = event.name ?? "unknown";
+        const input = event.input;
+        let detail = "";
+        if (input) {
+            // Show file path for Read/Write/Edit/Glob
+            const path = (input.file_path ?? input.path ?? input.pattern ?? input.command ?? "");
+            if (path)
+                detail = chalk.dim(` ${path.slice(0, 80)}`);
+        }
+        console.log(chalk.blue(`  → ${name}`) + detail);
+        displayed = true;
+    }
+    // Tool result — skip (too verbose)
+    // Assistant text — show thinking/status messages
+    if (type === "assistant") {
+        const msg = event.message;
+        const content = msg?.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === "text" && block.text) {
+                    const text = block.text.trim();
+                    displayed = emitVisibleAgentText(text, statusLogPath, lastVisibleText) || displayed;
+                }
+                if (block.type === "tool_use" && SHOW_AGENT_TOOL_EVENTS) {
+                    const name = block.name;
+                    const input = block.input;
+                    let detail = "";
+                    if (input) {
+                        const path = (input.file_path ?? input.path ?? input.pattern ?? input.command ?? "");
+                        if (path)
+                            detail = chalk.dim(` ${path.slice(0, 80)}`);
+                    }
+                    console.log(chalk.blue(`  → ${name}`) + detail);
+                    displayed = true;
+                }
+            }
+        }
+    }
+    if (type === "item.started" || type === "item.completed") {
+        const item = event.item;
+        if (item) {
+            displayed = displayItemEvent(type, item, statusLogPath, lastVisibleText) || displayed;
+        }
+    }
+    // Result — show final summary
+    if (type === "result") {
+        const result = event.result;
+        const subtype = event.subtype;
+        if (result && subtype !== "tool_result") {
+            const lines = result.split("\n");
+            for (const line of lines) {
+                displayed = emitVisibleAgentText(line, statusLogPath, lastVisibleText) || displayed;
+            }
+        }
+    }
+    const message = pickString(event.message) ??
+        pickString(event.text) ??
+        pickString(event.content) ??
+        pickString(event.output) ??
+        pickString(event.summary);
+    if (message && type !== "assistant" && type !== "result") {
+        const text = message.trim();
+        displayed = emitVisibleAgentText(text, statusLogPath, lastVisibleText) || displayed;
+    }
+    return displayed;
+}
+function pickString(value) {
+    if (typeof value === "string")
+        return value;
+    if (!Array.isArray(value))
+        return null;
+    for (const entry of value) {
+        if (typeof entry === "string")
+            return entry;
+        if (entry && typeof entry === "object" && "text" in entry && typeof entry.text === "string") {
+            return entry.text;
+        }
+    }
+    return null;
+}
+function displayItemEvent(type, item, statusLogPath, lastVisibleText) {
+    const itemType = item.type;
+    if (itemType === "agent_message") {
+        const text = item.text?.trim();
+        return text ? emitVisibleAgentText(text, statusLogPath, lastVisibleText) : false;
+    }
+    if (!SHOW_AGENT_TOOL_EVENTS) {
+        return false;
+    }
+    const title = pickString(item.title) ?? pickString(item.name);
+    const input = item.input;
+    const detail = input ? describeInput(input) : "";
+    if (type === "item.started" && title) {
+        console.log(chalk.blue(`  → ${title}`) + detail);
+        return true;
+    }
+    if (type === "item.completed" && title) {
+        console.log(chalk.blue(`  → ${title}`) + detail);
+        return true;
+    }
+    return false;
+}
+function describeInput(input) {
+    const path = (input.file_path ?? input.path ?? input.pattern ?? input.command ?? "");
+    return path ? chalk.dim(` ${path.slice(0, 80)}`) : "";
+}
+function shouldDisplayAgentText(text) {
+    if (text.length === 0 || text.length >= 300)
+        return false;
+    return VISIBLE_STATUS_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+function isTerminalVisibleStatus(text) {
+    return text.startsWith("DONE:") || text.startsWith("BLOCKED:") || text.startsWith("ERROR:");
+}
+export function extractAgentFailureStatus(event) {
+    const candidates = [];
+    const directMessage = pickString(event.message) ??
+        pickString(event.text) ??
+        pickString(event.content) ??
+        pickString(event.output) ??
+        pickString(event.summary);
+    if (directMessage)
+        candidates.push(directMessage);
+    const item = event.item;
+    if (item && typeof item === "object") {
+        const itemText = pickString(item.text);
+        if (itemText)
+            candidates.push(itemText);
+    }
+    for (const candidate of candidates) {
+        const text = candidate.trim();
+        if (text.startsWith("BLOCKED:") || text.startsWith("ERROR:")) {
+            return text;
+        }
+    }
+    return null;
+}
+function sanitizeAgentStderr(stderr) {
+    return stderr
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .filter((line) => !CODEX_NOISE_PATTERNS.some((pattern) => pattern.test(line)))
+        .join("\n")
+        .trim();
+}
+function validateInstalledSkill(agent, skillName) {
+    if (!skillName)
+        return null;
+    const localStatus = getAgentLocalSkillStatus(agent, skillName);
+    if (localStatus.current)
+        return null;
+    if (localStatus.present) {
+        return `Skill "${skillName}" is installed, but outdated. Run \`interf init\` and refresh Interf skills before syncing.`;
+    }
+    const installed = listInstalledSkills();
+    const bundledPath = join(SKILLS_DIR, skillName, "SKILL.md");
+    if (installed) {
+        const entry = installed.find((item) => item.name === skillName);
+        if (!entry) {
+            return `Skill "${skillName}" is not installed. Run \`interf init\` to install current Interf skills before syncing.`;
+        }
+        const agents = entry.agents ?? [];
+        if (agents.length > 0 && !agents.includes(agent.displayName)) {
+            return `Skill "${skillName}" is installed, but not for ${agent.displayName}. Run \`interf init\` and install skills for that agent before syncing.`;
+        }
+        if (existsSync(bundledPath)) {
+            const installedPath = entry.path ? join(entry.path, "SKILL.md") : null;
+            if (!installedPath || !bundledSkillMatchesInstalledPath(skillName, installedPath)) {
+                return `Skill "${skillName}" is installed, but outdated. Run \`interf init\` and refresh Interf skills before syncing.`;
+            }
+        }
+        return null;
+    }
+    const fallbackPaths = installedSkillCandidatePaths(agent, skillName);
+    if (fallbackPaths.length === 0) {
+        return `Skill "${skillName}" is not installed for ${agent.displayName}. Run \`interf init\` to install current Interf skills before syncing.`;
+    }
+    if (existsSync(bundledPath)) {
+        const hasCurrentCopy = fallbackPaths.some((path) => bundledSkillMatchesInstalledPath(skillName, path));
+        if (!hasCurrentCopy) {
+            return `Skill "${skillName}" is installed, but outdated. Run \`interf init\` and refresh Interf skills before syncing.`;
+        }
+    }
+    return null;
+}
+function ensureRequiredSkill(agent, skillName) {
+    const initialError = validateInstalledSkill(agent, skillName);
+    if (!initialError || !skillName)
+        return initialError;
+    if (autoRefreshAttemptedAgents.has(agent.name)) {
+        return initialError;
+    }
+    autoRefreshAttemptedAgents.add(agent.name);
+    console.log(chalk.dim(`  Refreshing Interf skills for ${agent.displayName}...`));
+    if (!refreshInterfSkills(agent)) {
+        return validateInstalledSkill(agent, skillName) ?? initialError;
+    }
+    const finalError = validateInstalledSkill(agent, skillName);
+    if (!finalError) {
+        console.log(chalk.dim("  Interf skills refreshed."));
+    }
+    return finalError;
+}
+function listInstalledSkills() {
+    if (installedSkillsCache)
+        return installedSkillsCache;
+    try {
+        const output = execFileSync("npx", SKILLS_LIST_ARGS, { encoding: "utf-8" });
+        installedSkillsCache = JSON.parse(output);
+        return installedSkillsCache;
+    }
+    catch {
+        return null;
+    }
+}
+function extractRequiredSkill(prompt) {
+    for (const line of prompt.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (!trimmed.startsWith("/"))
+            return null;
+        return trimmed.slice(1);
+    }
+    return null;
+}
+function listBundledInterfSkills() {
+    if (!existsSync(SKILLS_DIR))
+        return [];
+    return walkBundledInterfSkills(SKILLS_DIR);
+}
+function walkBundledInterfSkills(rootPath, prefix = "") {
+    const skills = [];
+    for (const entry of readdirSync(rootPath)) {
+        const dirPath = join(rootPath, entry);
+        if (!statSync(dirPath).isDirectory())
+            continue;
+        const skillName = prefix ? `${prefix}/${entry}` : entry;
+        if (existsSync(join(dirPath, "SKILL.md"))) {
+            skills.push(skillName);
+            continue;
+        }
+        skills.push(...walkBundledInterfSkills(dirPath, skillName));
+    }
+    return skills.sort();
+}
+function installedSkillCandidatePaths(agent, skillName) {
+    const candidates = new Set();
+    candidates.add(join(agent.skillsDir, skillName, "SKILL.md"));
+    candidates.add(join(homedir(), ".agents", "skills", skillName, "SKILL.md"));
+    return Array.from(candidates).filter((path) => existsSync(path));
+}
+function bundledSkillMatchesInstalledPath(skillName, installedSkillPath) {
+    const bundledSkillPath = join(SKILLS_DIR, skillName, "SKILL.md");
+    if (!existsSync(bundledSkillPath) || !existsSync(installedSkillPath))
+        return false;
+    const bundled = normalizeSkillDoc(readFileSync(bundledSkillPath, "utf-8"));
+    const installed = normalizeSkillDoc(readFileSync(installedSkillPath, "utf-8"));
+    return bundled === installed;
+}
+function normalizeSkillDoc(content) {
+    return content.replace(/\r\n/g, "\n").trim();
+}
+function getAgentLocalSkillStatus(agent, skillName) {
+    const localSkillPath = join(agent.skillsDir, skillName, "SKILL.md");
+    if (!existsSync(localSkillPath)) {
+        return { present: false, current: false };
+    }
+    return {
+        present: true,
+        current: bundledSkillMatchesInstalledPath(skillName, localSkillPath),
+    };
+}
+//# sourceMappingURL=agents.js.map