Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Predicate from "effect/Predicate";
/**
* ClaudeSkills — filesystem discovery of Claude Code skills for the `$` picker.
*
* Claude Code loads skills from `<config dir>/skills` (user scope), then
* `<cwd>/.agents/skills` and `<cwd>/.claude/skills` (project scope), one
* directory per skill with a `SKILL.md` carrying YAML frontmatter. Later roots
* win on name collisions, so precedence is user, `.agents`, then `.claude`.
* The Agent SDK init handshake surfaces skills only as slash commands without
* their filesystem paths, so the provider snapshot scans the same locations
* directly, mirroring how the Codex app-server reports its skills.
*
* @module provider/Drivers/ClaudeSkills
*/
import * as NodeOS from "node:os";
import type { ClaudeSettings, ServerProviderSkill } from "@akeru/contracts";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import { parse as parseYamlDocument } from "yaml";
import { expandHomePath } from "../../pathExpansion.ts";
type ClaudeSkillScope = "user" | "project";
const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
type SkillFrontmatter =
| { readonly kind: "missing" }
| { readonly kind: "malformed" }
| {
readonly kind: "parsed";
readonly name?: string;
readonly description?: string;
readonly icon?: string;
};
function parseSkillFrontmatter(contents: string): SkillFrontmatter {
const match = FRONTMATTER_PATTERN.exec(contents);
if (!match) {
return { kind: "missing" };
}
let parsed: unknown;
try {
parsed = parseYamlDocument(match[1] ?? "");
} catch {
return { kind: "malformed" };
}
if (!Predicate.isObjectOrArray(parsed) || parsed === null) {
return { kind: "malformed" };
}
const record = Array.isArray(parsed) ? {} : parsed;
const name = Predicate.isString(record.name) ? record.name.trim() : "";
const description = Predicate.isString(record.description) ? record.description.trim() : "";
const icon = Predicate.isString(record.icon) ? record.icon.trim() : "";
return {
kind: "parsed",
...(name ? { name } : {}),
...(description ? { description } : {}),
...(icon ? { icon } : {}),
};
}
/**
* Resolve the Claude config directory the CLI would use, matching the
* precedence the spawned CLI sees: the instance's `homePath` (exported as
* `CLAUDE_CONFIG_DIR` by `claudeEnvironment`), then a `CLAUDE_CONFIG_DIR`
* already present in the process environment, then `~/.claude`.
*/
const resolveClaudeConfigDirPath = Effect.fn("resolveClaudeConfigDirPath")(function* (
config: Pick<ClaudeSettings, "homePath">,
environment: NodeJS.ProcessEnv,
cwd?: string,
): Effect.fn.Return<string, never, Path.Path> {
const path = yield* Path.Path;
const homePath = config.homePath.trim();
if (homePath.length > 0) {
return path.resolve(expandHomePath(homePath, path));
}
// No tilde expansion here: the spawned CLI receives this env var verbatim
// (env vars are never shell-expanded), so a literal `~` must stay literal
// for discovery to scan the same directory the runtime would. A relative
// value is resolved against the workspace cwd — the subprocess's own cwd —
// for the same reason.
const environmentConfigDir = environment.CLAUDE_CONFIG_DIR?.trim() ?? "";
if (environmentConfigDir.length > 0) {
return cwd ? path.resolve(cwd, environmentConfigDir) : path.resolve(environmentConfigDir);
}
return path.join(NodeOS.homedir(), ".claude");
});
/**
* Enumerate Claude Code skills from the user config dir, workspace
* `.agents/skills`, and workspace `.claude/skills`, in that order. Discovery
* is best-effort: unreadable roots and malformed skill entries are skipped so
* a broken skill never degrades the provider snapshot. On name collisions,
* later roots win: `.agents` beats user and `.claude` beats `.agents`, matching
* Claude Code's resolution.
*/
export const discoverClaudeSkills = Effect.fn("discoverClaudeSkills")(function* (
config: Pick<ClaudeSettings, "homePath">,
cwd?: string,
environment?: NodeJS.ProcessEnv,
): Effect.fn.Return<ReadonlyArray<ServerProviderSkill>, never, FileSystem.FileSystem | Path.Path> {
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const configDirPath = yield* resolveClaudeConfigDirPath(config, environment ?? process.env, cwd);
const roots: ReadonlyArray<{ directory: string; scope: ClaudeSkillScope }> = [
{ directory: path.join(configDirPath, "skills"), scope: "user" },
...(cwd
? [
{ directory: path.join(cwd, ".agents", "skills"), scope: "project" as const },
{ directory: path.join(cwd, ".claude", "skills"), scope: "project" as const },
]
: []),
];
const skillsByName = new Map<string, ServerProviderSkill>();
for (const root of roots) {
const entries = yield* fileSystem
.readDirectory(root.directory)
.pipe(Effect.orElseSucceed((): ReadonlyArray<string> => []));
for (const entry of [...entries].sort()) {
const skillPath = path.join(root.directory, entry, "SKILL.md");
const contents = yield* fileSystem
.readFileString(skillPath)
.pipe(Effect.orElseSucceed(() => undefined));
if (contents === undefined) {
continue;
}
const frontmatter = parseSkillFrontmatter(contents);
// Malformed frontmatter means the skill won't load in Claude Code
// either — skip it rather than surfacing a broken entry under its
// directory name.
if (frontmatter.kind === "malformed") {
continue;
}
const name = (frontmatter.kind === "parsed" ? frontmatter.name : undefined) ?? entry.trim();
if (!name) {
continue;
}
skillsByName.set(name, {
name,
path: skillPath,
enabled: true,
scope: root.scope,
...(frontmatter.kind === "parsed" && frontmatter.description
? { description: frontmatter.description }
: {}),
...(frontmatter.kind === "parsed" && frontmatter.icon ? { icon: frontmatter.icon } : {}),
});
}
}
return [...skillsByName.values()].sort((left, right) => left.name.localeCompare(right.name));
});