@alan-ai-hq/agent-manager 0.1.113 → 0.1.115

package/dist/skills/local-skill-source.js

@@ -0,0 +1,660 @@
+import { Buffer } from "node:buffer";
+import { createHash, randomUUID } from "node:crypto";
+import { access, lstat, mkdir, readdir, readFile, realpath, writeFile } from "node:fs/promises";
+import path, { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { inspectSkillPackage } from "@alan-ai/shared/node/skill-package";
+import { providerKindsForUserDirectory, skillRepositorySourceDirectories, } from "@alan-ai/shared/skills";
+import { parse as parseToml } from "smol-toml";
+const DEFAULT_SKILL_CONFIG = `version = 1
+
+[skills]
+enabled = true
+discover_repository_skills = true
+ignore = ["**/.git/**", "**/node_modules/**"]
+
+[[skills.sources]]
+path = "~/.agents/skills"
+label = "Agent Skills"
+
+[[skills.sources]]
+path = "~/.alan/skill-sources"
+label = "Alan drafts"
+
+[[skills.sources]]
+path = "~/.claude/skills"
+label = "Claude skills"
+providers = ["claude_cli"]
+
+[[skills.sources]]
+path = "~/.cursor/skills"
+label = "Cursor skills"
+providers = ["cursor_agent_cli"]
+
+[[skills.sources]]
+path = "~/.codex/skills"
+label = "Codex skills"
+providers = ["codex_app_server"]
+
+[[skills.sources]]
+path = "~/.copilot/skills"
+label = "Copilot skills"
+providers = ["copilot_cli"]
+
+[[skills.sources]]
+path = "~/.config/opencode/skills"
+label = "OpenCode skills"
+providers = ["opencode_cli", "opencode_serve"]
+`;
+export class LocalSkillSource {
+    lastCompleteRevision = null;
+    locations = new Map();
+    inspectionCache = new Map();
+    async scan(input) {
+        const attemptId = randomUUID();
+        const diagnostics = [];
+        const candidates = [];
+        const visitedDirectories = new Set();
+        let incompleteRoot = false;
+        const resolvedRoots = resolveScanRoots(input.roots, input.enabledProviderKinds ?? []);
+        // The invariant is "inside a declared root", not "inside this one". Checking
+        // per-root rejected every symlink between two roots the user declared —
+        // which is how provider directories are laid out, so a whole root could
+        // resolve to nothing but rejections.
+        const declaredRoots = await canonicalDirectories(resolvedRoots.map((root) => root.directory));
+        for (const resolvedRoot of resolvedRoots) {
+            const rootResult = await this.scanRoot(resolvedRoot, visitedDirectories, input.ignoredPaths ?? [], input.mode, declaredRoots);
+            candidates.push(...rootResult.candidates);
+            diagnostics.push(...rootResult.diagnostics);
+            incompleteRoot ||= rootResult.incomplete;
+        }
+        if (incompleteRoot) {
+            return {
+                status: "partial",
+                attemptId,
+                retainedInventoryRevision: this.lastCompleteRevision,
+                diagnostics: diagnostics.slice(0, 100),
+            };
+        }
+        candidates.sort((left, right) => left.order === right.order
+            ? left.candidate.name.localeCompare(right.candidate.name)
+            : left.order.localeCompare(right.order));
+        const uniqueCandidates = deduplicateCandidatesByContent(candidates);
+        const visibleCandidates = uniqueCandidates.slice(0, 2_000);
+        if (uniqueCandidates.length > visibleCandidates.length) {
+            return {
+                status: "partial",
+                attemptId,
+                retainedInventoryRevision: this.lastCompleteRevision,
+                diagnostics: [
+                    ...diagnostics.slice(0, 99),
+                    {
+                        code: "SCAN_LIMIT_EXCEEDED",
+                        message: "Skill scan found more than 2,000 candidates",
+                    },
+                ],
+            };
+        }
+        this.locations = new Map(visibleCandidates.map(({ candidate, absolutePath }) => [candidate.localKey, absolutePath]));
+        const inventory = visibleCandidates.map(({ candidate }) => candidate);
+        const inventoryRevision = hashInventory(inventory);
+        this.lastCompleteRevision = inventoryRevision;
+        return {
+            status: "complete",
+            attemptId,
+            inventoryRevision,
+            candidates: inventory,
+            diagnostics: diagnostics.slice(0, 100),
+        };
+    }
+    resolvePackage(localKey) {
+        return this.locations.get(localKey) ?? null;
+    }
+    async inspectPackage(absolutePath, expectedContentHash) {
+        const cached = this.inspectionCache.get(absolutePath)?.inspected;
+        if (cached?.contentHash === expectedContentHash)
+            return cached;
+        return inspectSkillPackage(absolutePath, { expectedName: null });
+    }
+    /**
+     * The root read as one package, or null when it does not hold a SKILL.md.
+     *
+     * `expectedName` is null here on purpose. A package inside a library must be
+     * named for its directory, but a root is whatever the person called the
+     * folder, so that rule would reject it with DIRECTORY_NAME_MISMATCH.
+     */
+    async scanRootAsPackage(resolvedRoot, ignoredPaths, mode) {
+        const directory = resolvedRoot.directory;
+        if (!(await pathExists(join(directory, "SKILL.md"))))
+            return null;
+        const canonicalRoot = await realpath(directory).catch(() => directory);
+        const name = path.basename(canonicalRoot);
+        try {
+            const fingerprint = await fingerprintPackage(canonicalRoot);
+            const ignoreSignature = JSON.stringify(ignoredPaths);
+            const cached = this.inspectionCache.get(canonicalRoot);
+            const inspected = mode === "incremental" &&
+                cached?.fingerprint === fingerprint &&
+                cached.ignoreSignature === ignoreSignature
+                ? cached.inspected
+                : await inspectSkillPackage(canonicalRoot, { ignoredPaths, expectedName: null });
+            this.inspectionCache.set(canonicalRoot, { fingerprint, ignoreSignature, inspected });
+            return {
+                candidates: [
+                    {
+                        absolutePath: canonicalRoot,
+                        rootPath: canonicalRoot,
+                        order: `${resolvedRoot.order}:${name}`,
+                        candidate: {
+                            localKey: createLocalKey(resolvedRoot.root, inspected.metadata.name),
+                            name: inspected.metadata.name,
+                            description: inspected.metadata.description,
+                            contentHash: inspected.contentHash,
+                            fileCount: inspected.fileCount,
+                            totalBytes: inspected.totalBytes,
+                            origin: candidateOrigin(resolvedRoot.root),
+                            diagnostics: inspected.diagnostics,
+                        },
+                    },
+                ],
+                diagnostics: [],
+                incomplete: false,
+            };
+        }
+        catch (error) {
+            return {
+                candidates: [],
+                diagnostics: [
+                    {
+                        code: "INVALID_SKILL",
+                        message: error instanceof Error ? error.message : String(error),
+                        rootLabel: resolvedRoot.root.label,
+                        localKey: createLocalKey(resolvedRoot.root, name),
+                    },
+                ],
+                incomplete: false,
+            };
+        }
+    }
+    async scanRoot(resolvedRoot, visitedDirectories, ignoredPaths, mode, declaredRoots) {
+        // A source can be a Skill rather than a directory of them. A root holding
+        // its own SKILL.md is the package, and its subdirectories are that
+        // package's files, so this returns instead of also walking children.
+        const rootPackage = await this.scanRootAsPackage(resolvedRoot, ignoredPaths, mode);
+        if (rootPackage)
+            return rootPackage;
+        let entries;
+        try {
+            entries = await readdir(resolvedRoot.directory, { withFileTypes: true });
+        }
+        catch (error) {
+            if (isAbsentDirectory(error))
+                return { candidates: [], diagnostics: [], incomplete: false };
+            return {
+                candidates: [],
+                diagnostics: [
+                    {
+                        code: "SOURCE_UNREADABLE",
+                        message: `Could not read ${resolvedRoot.root.label}`,
+                        rootLabel: resolvedRoot.root.label,
+                    },
+                ],
+                incomplete: true,
+            };
+        }
+        const candidates = [];
+        const diagnostics = [];
+        const canonicalRoot = await realpath(resolvedRoot.directory).catch(() => resolvedRoot.directory);
+        for (const entry of entries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const candidatePath = join(resolvedRoot.directory, entry.name);
+            const canonicalPath = await realpath(candidatePath).catch(() => null);
+            if (!canonicalPath) {
+                diagnostics.push({
+                    code: "SOURCE_UNREADABLE",
+                    message: `Could not resolve Skill ${entry.name}`,
+                    rootLabel: resolvedRoot.root.label,
+                });
+                continue;
+            }
+            // A symlink into another declared root is a duplicate, not an escape:
+            // nothing is read that some root was not already going to read, and the
+            // canonical-path check below collapses it. Only a target no declared root
+            // covers is a real escape.
+            const roots = declaredRoots.length > 0 ? declaredRoots : [canonicalRoot];
+            if (!roots.some((root) => isWithinDirectory(root, canonicalPath))) {
+                diagnostics.push({
+                    code: "SOURCE_OUTSIDE_DECLARED_ROOT",
+                    message: `Skill ${entry.name} resolves outside every declared Skill source`,
+                    rootLabel: resolvedRoot.root.label,
+                });
+                continue;
+            }
+            if (!(await isDirectory(canonicalPath)))
+                continue;
+            if (visitedDirectories.has(canonicalPath))
+                continue;
+            visitedDirectories.add(canonicalPath);
+            if (await hasManagedMarker(canonicalPath))
+                continue;
+            try {
+                const fingerprint = await fingerprintPackage(canonicalPath);
+                const ignoreSignature = JSON.stringify(ignoredPaths);
+                const cached = this.inspectionCache.get(canonicalPath);
+                const inspected = mode === "incremental" &&
+                    cached?.fingerprint === fingerprint &&
+                    cached.ignoreSignature === ignoreSignature
+                    ? cached.inspected
+                    : await inspectSkillPackage(canonicalPath, { ignoredPaths });
+                this.inspectionCache.set(canonicalPath, { fingerprint, ignoreSignature, inspected });
+                const localKey = createLocalKey(resolvedRoot.root, entry.name);
+                candidates.push({
+                    absolutePath: canonicalPath,
+                    rootPath: canonicalRoot,
+                    order: `${resolvedRoot.order}:${entry.name}`,
+                    candidate: {
+                        localKey,
+                        name: inspected.metadata.name,
+                        description: inspected.metadata.description,
+                        contentHash: inspected.contentHash,
+                        fileCount: inspected.fileCount,
+                        totalBytes: inspected.totalBytes,
+                        origin: candidateOrigin(resolvedRoot.root),
+                        diagnostics: inspected.diagnostics,
+                    },
+                });
+            }
+            catch (error) {
+                diagnostics.push({
+                    code: "INVALID_SKILL",
+                    message: error instanceof Error ? error.message : String(error),
+                    rootLabel: resolvedRoot.root.label,
+                    localKey: createLocalKey(resolvedRoot.root, entry.name),
+                });
+            }
+        }
+        return { candidates, diagnostics, incomplete: false };
+    }
+}
+async function fingerprintPackage(root) {
+    const hash = createHash("sha256").update("alan-skill-stat-fingerprint-v1\0");
+    await visit(root, "");
+    return `sha256:${hash.digest("hex")}`;
+    async function visit(directory, relativeDirectory) {
+        const entries = await readdir(directory, { withFileTypes: true });
+        entries.sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
+        for (const entry of entries) {
+            const path = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
+            const absolutePath = join(directory, entry.name);
+            const metadata = await lstat(absolutePath);
+            hash
+                .update(path.normalize("NFC"))
+                .update("\0")
+                .update(entry.isDirectory() ? "d" : entry.isFile() ? "f" : entry.isSymbolicLink() ? "l" : "o")
+                .update("\0")
+                .update(String(metadata.size))
+                .update("\0")
+                .update(String(metadata.mtimeMs))
+                .update("\0")
+                .update(String(metadata.mode & 0o777))
+                .update("\0");
+            if (entry.isDirectory())
+                await visit(absolutePath, path);
+        }
+    }
+}
+const CODEX_SOURCE_LABEL = "Codex skills";
+const STALE_CODEX_LABEL = "Legacy Cursor-compatible skills";
+const STALE_CODEX_PROVIDER = "cursor_agent_cli";
+/**
+ * The V1 preview wrote `~/.codex/skills` as a Cursor source, so every existing
+ * install files its Codex Skills under Cursor and labels them as Cursor's.
+ *
+ * Corrected here rather than by rewriting the file: the TOML is the user's, and
+ * a load-time rewrite would reformat it and drop their comments to fix two
+ * values. Reading it correctly repairs every install on the next scan and
+ * leaves anyone who deliberately renamed the source alone, since this only
+ * fires on the exact pair the preview shipped.
+ */
+function staleCodexDeclaration(relativeDirectory, label, providerKinds) {
+    const normalized = relativeDirectory.replaceAll("\\", "/").replace(/^\.\//, "");
+    if (normalized !== ".codex/skills")
+        return false;
+    const ownedByCursor = providerKinds !== undefined &&
+        providerKinds.length === 1 &&
+        providerKinds[0] === STALE_CODEX_PROVIDER;
+    return ownedByCursor || label === STALE_CODEX_LABEL;
+}
+async function canonicalDirectories(directories) {
+    const canonical = await Promise.all(directories.map((directory) => realpath(directory).catch(() => directory)));
+    return [...new Set(canonical)];
+}
+function isWithinDirectory(parent, candidate) {
+    const path = relative(parent, candidate);
+    return path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+/**
+ * Add a folder the person picked to their own Skill sources.
+ *
+ * Appended as text rather than written from a re-serialized config: the TOML is
+ * theirs, and round-tripping it through a parser would silently reformat it and
+ * drop their comments. Elsewhere this file goes out of its way not to rewrite
+ * that file at all; here the write is the thing the person asked for, and it is
+ * additive.
+ *
+ * A folder already covered by a source is reported rather than added twice,
+ * because a second root over the same directory only produces rows the scan
+ * then has to deduplicate.
+ */
+export async function addSkillSource(homeDirectory, input) {
+    const label = input.label.trim();
+    if (!label)
+        return { state: "invalid", diagnostic: "A source needs a label" };
+    const sourcePath = resolveSkillSourcePath(input.path, homeDirectory);
+    if (!(await isDirectory(sourcePath))) {
+        return { state: "invalid", diagnostic: `${sourcePath} is not a folder` };
+    }
+    const loaded = await loadSkillSourceConfig(homeDirectory);
+    if (loaded.state === "invalid") {
+        return { state: "invalid", diagnostic: loaded.diagnostic };
+    }
+    const canonical = await realpath(sourcePath).catch(() => sourcePath);
+    for (const source of loaded.config.sources) {
+        const existing = await realpath(source.path).catch(() => source.path);
+        if (existing === canonical) {
+            return { state: "already_present", label: source.label, config: loaded.config };
+        }
+    }
+    const configPath = join(homeDirectory, ".alan", "config.toml");
+    const current = await readFile(configPath, "utf8");
+    const block = [
+        "",
+        "[[skills.sources]]",
+        `path = ${tomlString(sourcePath)}`,
+        `label = ${tomlString(label)}`,
+        "",
+    ].join("\n");
+    await writeFile(configPath, `${current.replace(/\n*$/, "\n")}${block}`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    const reloaded = await loadSkillSourceConfig(homeDirectory);
+    if (reloaded.state === "invalid") {
+        return { state: "invalid", diagnostic: reloaded.diagnostic };
+    }
+    return { state: "added", label, config: reloaded.config };
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+export async function loadSkillSourceConfig(homeDirectory) {
+    const configDirectory = join(homeDirectory, ".alan");
+    const configPath = join(configDirectory, "config.toml");
+    await mkdir(configDirectory, { recursive: true, mode: 0o700 });
+    let created = false;
+    try {
+        await writeFile(configPath, DEFAULT_SKILL_CONFIG, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        created = true;
+    }
+    catch (error) {
+        if (!isAlreadyPresent(error))
+            throw error;
+    }
+    const content = await readFile(configPath, "utf8");
+    try {
+        return { state: "ready", config: parseSkillSourceConfig(content, homeDirectory), created };
+    }
+    catch (error) {
+        return {
+            state: "invalid",
+            config: parseSkillSourceConfig(DEFAULT_SKILL_CONFIG, homeDirectory),
+            created: false,
+            diagnostic: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function resolveSkillScanInput(homeDirectory, declared) {
+    const loaded = await loadSkillSourceConfig(homeDirectory);
+    if (loaded.state === "invalid") {
+        throw Object.assign(new Error(`Invalid Skill source configuration: ${loaded.diagnostic}`), {
+            code: "SKILL_SOURCE_CONFIG_INVALID",
+        });
+    }
+    const { config } = loaded;
+    if (!config.enabled)
+        return { ...declared, roots: [], ignoredPaths: config.ignoredPaths };
+    const draftsPath = resolve(join(homeDirectory, ".alan", "skill-sources"));
+    const enabledProviders = new Set(declared.enabledProviderKinds ?? []);
+    const configured = [];
+    for (const source of config.sources) {
+        if (source.providerKinds !== undefined &&
+            !source.providerKinds.some((provider) => enabledProviders.has(provider))) {
+            continue;
+        }
+        configured.push(resolve(source.path) === draftsPath
+            ? { kind: "drafts", path: source.path, label: "Alan drafts" }
+            : {
+                kind: "configured",
+                declarationId: source.declarationId,
+                path: source.path,
+                label: source.label,
+                precedence: source.precedence,
+            });
+    }
+    const repositories = config.discoverRepositorySkills
+        ? declared.roots.filter((root) => root.kind === "repository")
+        : [];
+    return {
+        ...declared,
+        roots: [...configured, ...repositories],
+        ignoredPaths: [...new Set([...config.ignoredPaths, ...(declared.ignoredPaths ?? [])])],
+    };
+}
+function parseSkillSourceConfig(content, homeDirectory) {
+    const parsed = parseToml(content);
+    if (!isRecord(parsed) || parsed.version !== 1 || !isRecord(parsed.skills)) {
+        throw new Error("~/.alan/config.toml must contain version = 1 and a [skills] table");
+    }
+    const skills = parsed.skills;
+    const enabled = optionalBoolean(skills.enabled, true, "skills.enabled");
+    const discoverRepositorySkills = optionalBoolean(skills.discover_repository_skills, true, "skills.discover_repository_skills");
+    const ignoredPaths = optionalStringArray(skills.ignore, "skills.ignore");
+    if (!Array.isArray(skills.sources)) {
+        throw new Error("~/.alan/config.toml must declare at least one [[skills.sources]] table");
+    }
+    const sources = skills.sources.map((value, index) => {
+        if (!isRecord(value) || typeof value.path !== "string" || typeof value.label !== "string") {
+            throw new Error(`skills.sources entry ${index + 1} must contain string path and label values`);
+        }
+        const sourcePath = resolveSkillSourcePath(value.path, homeDirectory);
+        const label = value.label.trim();
+        if (!label)
+            throw new Error(`skills.sources entry ${index + 1} has an empty label`);
+        const declarationId = value.id === undefined
+            ? stableSourceDeclarationId(sourcePath)
+            : requiredSourceId(value.id, `skills.sources[${index}].id`);
+        const explicitProviders = optionalStringArray(value.providers, `skills.sources[${index}].providers`);
+        const relativeDirectory = path.relative(homeDirectory, sourcePath);
+        const inferredProviders = providerKindsForUserDirectory(relativeDirectory);
+        const declaredProviders = value.providers === undefined
+            ? inferredProviders
+            : [...new Set(explicitProviders.map((provider) => provider.trim()).filter(Boolean))];
+        const stale = staleCodexDeclaration(relativeDirectory, label, declaredProviders);
+        return {
+            declarationId,
+            path: sourcePath,
+            label: stale ? CODEX_SOURCE_LABEL : label,
+            precedence: index,
+            providerKinds: stale ? inferredProviders : declaredProviders,
+        };
+    });
+    const duplicateId = sources.find((source, index) => sources.findIndex((candidate) => candidate.declarationId === source.declarationId) !== index);
+    if (duplicateId) {
+        throw new Error(`skills.sources contains duplicate source id ${duplicateId.declarationId}`);
+    }
+    return { enabled, discoverRepositorySkills, ignoredPaths, sources };
+}
+function stableSourceDeclarationId(sourcePath) {
+    const digest = createHash("sha256")
+        .update("alan-skill-source-v1\0")
+        .update(sourcePath.normalize("NFC"))
+        .digest("hex")
+        .slice(0, 24);
+    return `source-${digest}`;
+}
+function requiredSourceId(value, field) {
+    if (typeof value !== "string" || !/^[a-z0-9]+(?:[-_.][a-z0-9]+)*$/i.test(value)) {
+        throw new Error(`${field} must be a stable identifier containing letters, numbers, -, _, or .`);
+    }
+    return value;
+}
+export function resolveSkillSourcePath(sourcePath, homeDirectory, pathApi = path) {
+    const trimmed = sourcePath.trim();
+    if (trimmed === "~")
+        return pathApi.resolve(homeDirectory);
+    if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+        const components = trimmed
+            .slice(2)
+            .split(/[\\/]+/)
+            .filter(Boolean);
+        return pathApi.resolve(pathApi.join(homeDirectory, ...components));
+    }
+    return pathApi.isAbsolute(trimmed)
+        ? pathApi.resolve(trimmed)
+        : pathApi.resolve(homeDirectory, trimmed);
+}
+function optionalBoolean(value, fallback, field) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "boolean")
+        throw new Error(`${field} must be true or false`);
+    return value;
+}
+function optionalStringArray(value, field) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new Error(`${field} must be an array of strings`);
+    }
+    return value;
+}
+function resolveScanRoots(roots, enabledProviderKinds) {
+    const resolved = [];
+    for (const root of roots) {
+        if (root.kind === "repository") {
+            for (const [index, relativeDirectory] of skillRepositorySourceDirectories(enabledProviderKinds).entries()) {
+                resolved.push({
+                    root,
+                    directory: join(root.path, relativeDirectory),
+                    order: `1:${root.repositoryId}:${String(index).padStart(2, "0")}`,
+                });
+            }
+            continue;
+        }
+        resolved.push({
+            root,
+            directory: root.path,
+            order: root.kind === "configured"
+                ? `0:${String(root.precedence).padStart(8, "0")}:${root.declarationId}`
+                : "2:drafts",
+        });
+    }
+    return resolved.sort((left, right) => left.order.localeCompare(right.order));
+}
+function candidateOrigin(root) {
+    if (root.kind === "repository") {
+        return { kind: "repository", label: root.label, repositoryId: root.repositoryId };
+    }
+    return { kind: root.kind, label: root.label };
+}
+function createLocalKey(root, skillName) {
+    const rootIdentity = root.kind === "configured"
+        ? `configured:${root.declarationId}`
+        : root.kind === "repository"
+            ? `repository:${root.repositoryId}`
+            : "drafts";
+    const digest = createHash("sha256")
+        .update("alan-local-skill-v1\0")
+        .update(rootIdentity)
+        .update("\0")
+        .update(skillName.normalize("NFC"))
+        .digest("hex");
+    return `local:${digest}`;
+}
+function hashInventory(candidates) {
+    const hash = createHash("sha256");
+    hash.update("alan-skill-inventory-v1\0");
+    for (const candidate of candidates) {
+        hash.update(candidate.localKey);
+        hash.update("\0");
+        hash.update(candidate.contentHash);
+        hash.update("\0");
+        hash.update(candidate.name);
+        hash.update("\0");
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+/**
+ * One row per package, attributed to the most specific source that covers it.
+ *
+ * Sources nest: pointing Alan at one Skill inside a library leaves two roots
+ * over the same package. The deeper root is the more specific statement of
+ * where it lives, so it wins over whichever happened to be declared first.
+ */
+function deduplicateCandidatesByContent(candidates) {
+    const bestByContent = new Map();
+    for (const located of candidates) {
+        const existing = bestByContent.get(located.candidate.contentHash);
+        if (!existing || located.rootPath.length > existing.rootPath.length) {
+            bestByContent.set(located.candidate.contentHash, located);
+        }
+    }
+    const winners = new Set(bestByContent.values());
+    return candidates.filter((located) => winners.has(located));
+}
+async function pathExists(candidate) {
+    try {
+        await access(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasManagedMarker(directory) {
+    try {
+        await access(join(directory, ".alan-managed.json"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(path) {
+    try {
+        return (await lstat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isAbsentDirectory(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        ["ENOENT", "ENOTDIR"].includes(String(error.code)));
+}
+function isAlreadyPresent(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "EEXIST");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=local-skill-source.js.map