dryai 0.2.1

package/dest/lib/skills.d.ts

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+import type { AgentsContext } from './context.js';
+declare const skillLockEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    repo: z.ZodString;
+    path: z.ZodString;
+    ref: z.ZodOptional<z.ZodString>;
+    commit: z.ZodString;
+    importedAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    repo: string;
+    path: string;
+    commit: string;
+    importedAt: string;
+    updatedAt: string;
+    ref?: string | undefined;
+}, {
+    name: string;
+    repo: string;
+    path: string;
+    commit: string;
+    importedAt: string;
+    updatedAt: string;
+    ref?: string | undefined;
+}>;
+declare const skillsLockfileSchema: z.ZodEffects<z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    skills: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        repo: z.ZodString;
+        path: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        commit: z.ZodString;
+        importedAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        repo: string;
+        path: string;
+        commit: string;
+        importedAt: string;
+        updatedAt: string;
+        ref?: string | undefined;
+    }, {
+        name: string;
+        repo: string;
+        path: string;
+        commit: string;
+        importedAt: string;
+        updatedAt: string;
+        ref?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    skills: {
+        name: string;
+        repo: string;
+        path: string;
+        commit: string;
+        importedAt: string;
+        updatedAt: string;
+        ref?: string | undefined;
+    }[];
+}, {
+    version: 1;
+    skills: {
+        name: string;
+        repo: string;
+        path: string;
+        commit: string;
+        importedAt: string;
+        updatedAt: string;
+        ref?: string | undefined;
+    }[];
+}>, {
+    version: 1;
+    skills: {
+        name: string;
+        repo: string;
+        path: string;
+        commit: string;
+        importedAt: string;
+        updatedAt: string;
+        ref?: string | undefined;
+    }[];
+}, {
+    version: 1;
+    skills: {
+        name: string;
+        repo: string;
+        path: string;
+        commit: string;
+        importedAt: string;
+        updatedAt: string;
+        ref?: string | undefined;
+    }[];
+}>;
+export type ManagedSkill = z.infer<typeof skillLockEntrySchema>;
+export type SkillsLockfile = z.infer<typeof skillsLockfileSchema>;
+export type RemoteSkillSnapshot = {
+    cleanup: () => Promise<void>;
+    commit: string;
+    sourceDir: string;
+};
+export type RemoteRepoCheckout = {
+    checkoutDir: string;
+    cleanup: () => Promise<void>;
+    commit: string;
+};
+export declare function createEmptySkillsLockfile(): SkillsLockfile;
+export declare function ensureSkillsRoot(context: AgentsContext): Promise<void>;
+export declare function ensureSkillsLockfile(context: AgentsContext): Promise<void>;
+export declare function loadSkillsLockfile(context: AgentsContext): Promise<SkillsLockfile>;
+export declare function saveSkillsLockfile(context: AgentsContext, { lockfile }: {
+    lockfile: SkillsLockfile;
+}): Promise<void>;
+export declare function findManagedSkill(lockfile: SkillsLockfile, { name }: {
+    name: string;
+}): ManagedSkill | undefined;
+export declare function upsertManagedSkill(lockfile: SkillsLockfile, { updatedSkill }: {
+    updatedSkill: ManagedSkill;
+}): SkillsLockfile;
+export declare function removeManagedSkill(lockfile: SkillsLockfile, { name }: {
+    name: string;
+}): SkillsLockfile;
+export declare function listLocalSkillDirectories(context: AgentsContext): Promise<string[]>;
+export declare function getManagedSkillDirectory(context: AgentsContext, { skillName }: {
+    skillName: string;
+}): string;
+export declare function deriveSkillName({ repo, skillPath, explicitName, }: {
+    repo: string;
+    skillPath: string;
+    explicitName: string | undefined;
+}): string;
+export declare function normalizeRemoteRepo(repo: string): string;
+/**
+ * Builds the canonical remote path for a managed skill under the repository `skills/` directory.
+ */
+export declare function resolveManagedSkillImportPath({ skillName, }: {
+    skillName: string;
+}): string;
+export declare function normalizeImportedSkillPath(skillPath: string | undefined): string;
+export declare function createImportedSkillRecord(input: {
+    commit: string;
+    importedAt: string;
+    name: string;
+    path: string;
+    ref: string | undefined;
+    repo: string;
+}): ManagedSkill;
+export declare function createUpdatedSkillRecord(input: {
+    commit: string;
+    existingSkill: ManagedSkill;
+    updatedAt: string;
+}): ManagedSkill;
+/**
+ * Clones a remote repository into a temporary checkout and resolves the fetched commit.
+ */
+export declare function cloneRemoteRepo(input: {
+    ref: string | undefined;
+    repo: string;
+}): Promise<RemoteRepoCheckout>;
+/**
+ * Resolves and validates a managed skill directory from a temporary repository checkout.
+ */
+export declare function resolveSkillSourceDir(input: {
+    checkoutDir: string;
+    repo: string;
+    skillName: string;
+}): Promise<string>;
+/**
+ * Fetches a validated remote skill directory snapshot for a specific repository path.
+ */
+export declare function fetchRemoteSkillSnapshot(input: {
+    ref: string | undefined;
+    repo: string;
+    skillPath: string;
+}): Promise<RemoteSkillSnapshot>;
+export declare function replaceManagedSkillDirectory({ targetDir, sourceDir, }: {
+    targetDir: string;
+    sourceDir: string;
+}): Promise<void>;
+export declare function removeManagedSkillDirectory(context: AgentsContext, { skillName }: {
+    skillName: string;
+}): Promise<void>;
+export declare function formatManagedSkillSummary(skill: ManagedSkill): string;
+export declare function shortCommit(commit: string): string;
+export declare function timestampNow(): string;
+export {};
+//# sourceMappingURL=skills.d.ts.map

package/dest/lib/skills.js

@@ -0,0 +1,329 @@
+import fs from 'fs-extra';
+import os from 'node:os';
+import path from 'node:path';
+import { simpleGit } from 'simple-git';
+import { z } from 'zod';
+const skillLockEntrySchema = z.object({
+    name: z.string().min(1),
+    repo: z.string().min(1),
+    path: z.string().min(1),
+    ref: z.string().min(1).optional(),
+    commit: z.string().min(1),
+    importedAt: z.string().datetime({ offset: true }),
+    updatedAt: z.string().datetime({ offset: true }),
+});
+const skillsLockfileSchema = z
+    .object({
+    version: z.literal(1),
+    skills: z.array(skillLockEntrySchema),
+})
+    .superRefine((lockfile, refinementContext) => {
+    const seenNames = new Set();
+    lockfile.skills.forEach((skill, index) => {
+        if (seenNames.has(skill.name)) {
+            refinementContext.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Duplicate managed skill name: ${skill.name}`,
+                path: ['skills', index, 'name'],
+            });
+            return;
+        }
+        seenNames.add(skill.name);
+    });
+});
+export function createEmptySkillsLockfile() {
+    return {
+        version: 1,
+        skills: [],
+    };
+}
+export async function ensureSkillsRoot(context) {
+    await fs.ensureDir(context.sourceRoots.skills);
+}
+export async function ensureSkillsLockfile(context) {
+    if (await fs.pathExists(context.skillsLockfilePath)) {
+        return;
+    }
+    await saveSkillsLockfile(context, { lockfile: createEmptySkillsLockfile() });
+}
+export async function loadSkillsLockfile(context) {
+    if (!(await fs.pathExists(context.skillsLockfilePath))) {
+        return createEmptySkillsLockfile();
+    }
+    const rawLockfile = await fs.readFile(context.skillsLockfilePath, 'utf8');
+    const parsedJson = JSON.parse(rawLockfile);
+    const parsedLockfile = skillsLockfileSchema.safeParse(parsedJson);
+    if (parsedLockfile.success) {
+        return sortSkillsLockfile(parsedLockfile.data);
+    }
+    const issues = parsedLockfile.error.issues
+        .map((issue) => {
+        const issuePath = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `- ${issuePath}: ${issue.message}`;
+    })
+        .join('\n');
+    throw new Error(`Invalid skills lockfile at ${context.skillsLockfilePath}:\n${issues}`);
+}
+export async function saveSkillsLockfile(context, { lockfile }) {
+    const normalizedLockfile = sortSkillsLockfile(lockfile);
+    await fs.writeFile(context.skillsLockfilePath, `${JSON.stringify(normalizedLockfile, null, 2)}\n`, 'utf8');
+}
+export function findManagedSkill(lockfile, { name }) {
+    return lockfile.skills.find((skill) => skill.name === name);
+}
+export function upsertManagedSkill(lockfile, { updatedSkill }) {
+    const remainingSkills = lockfile.skills.filter((skill) => skill.name !== updatedSkill.name);
+    return sortSkillsLockfile({
+        version: lockfile.version,
+        skills: [...remainingSkills, updatedSkill],
+    });
+}
+export function removeManagedSkill(lockfile, { name }) {
+    return sortSkillsLockfile({
+        version: lockfile.version,
+        skills: lockfile.skills.filter((skill) => skill.name !== name),
+    });
+}
+export async function listLocalSkillDirectories(context) {
+    await ensureSkillsRoot(context);
+    const entries = await fs.readdir(context.sourceRoots.skills, {
+        withFileTypes: true,
+    });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+}
+export function getManagedSkillDirectory(context, { skillName }) {
+    return path.join(context.sourceRoots.skills, skillName);
+}
+export function deriveSkillName({ repo, skillPath, explicitName, }) {
+    const candidateName = explicitName ?? inferDefaultSkillName({ repo, skillPath });
+    if (candidateName.length === 0 ||
+        candidateName === '.' ||
+        candidateName === '..' ||
+        candidateName.includes('/') ||
+        candidateName.includes('\\')) {
+        throw new Error(`Invalid skill name: ${candidateName}`);
+    }
+    return candidateName;
+}
+export function normalizeRemoteRepo(repo) {
+    const trimmedRepo = repo.trim();
+    if (trimmedRepo.length === 0) {
+        throw new Error('Repository may not be empty');
+    }
+    if (githubRepoShorthandPattern.test(trimmedRepo)) {
+        const [owner, rawRepoName] = trimmedRepo.split('/');
+        const repoName = rawRepoName.endsWith('.git')
+            ? rawRepoName.slice(0, -4)
+            : rawRepoName;
+        return `https://github.com/${owner}/${repoName}.git`;
+    }
+    return trimmedRepo;
+}
+/**
+ * Builds the canonical remote path for a managed skill under the repository `skills/` directory.
+ */
+export function resolveManagedSkillImportPath({ skillName, }) {
+    const trimmedSkillName = skillName.trim();
+    if (trimmedSkillName.length === 0 ||
+        trimmedSkillName === '.' ||
+        trimmedSkillName === '..' ||
+        trimmedSkillName.includes('/') ||
+        trimmedSkillName.includes('\\')) {
+        throw new Error(`Invalid skill name: ${skillName}`);
+    }
+    return `skills/${trimmedSkillName}`;
+}
+export function normalizeImportedSkillPath(skillPath) {
+    const normalizedPath = skillPath && skillPath.length > 0 ? skillPath : '.';
+    return path.normalize(normalizedPath);
+}
+export function createImportedSkillRecord(input) {
+    return {
+        commit: input.commit,
+        importedAt: input.importedAt,
+        name: input.name,
+        path: input.path,
+        ref: input.ref,
+        repo: input.repo,
+        updatedAt: input.importedAt,
+    };
+}
+export function createUpdatedSkillRecord(input) {
+    return {
+        ...input.existingSkill,
+        commit: input.commit,
+        updatedAt: input.updatedAt,
+    };
+}
+/**
+ * Clones a remote repository into a temporary checkout and resolves the fetched commit.
+ */
+export async function cloneRemoteRepo(input) {
+    const normalizedRepo = normalizeRemoteRepo(input.repo);
+    const checkoutDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agents-skill.'));
+    try {
+        const git = simpleGit(checkoutDir);
+        await git.init();
+        await git.addRemote('origin', normalizedRepo);
+        if (input.ref) {
+            await git.fetch('origin', input.ref, ['--depth', '1']);
+        }
+        else {
+            await git.fetch('origin', 'HEAD', ['--depth', '1']);
+        }
+        await git.checkout(['--quiet', 'FETCH_HEAD']);
+        return {
+            checkoutDir,
+            cleanup: async () => {
+                await fs.remove(checkoutDir);
+            },
+            commit: await git.revparse(['HEAD']),
+        };
+    }
+    catch (error) {
+        await fs.remove(checkoutDir);
+        throw toError({
+            prefix: `Failed to fetch repository from ${normalizedRepo}`,
+            error,
+        });
+    }
+}
+/**
+ * Resolves and validates a managed skill directory from a temporary repository checkout.
+ */
+export async function resolveSkillSourceDir(input) {
+    const skillPath = resolveManagedSkillImportPath({
+        skillName: input.skillName,
+    });
+    const sourceDir = resolveRemoteSkillDirectory({
+        checkoutDir: input.checkoutDir,
+        skillPath,
+    });
+    await validateRemoteSkillDirectory({
+        sourceDir,
+        skillPath,
+        repo: normalizeRemoteRepo(input.repo),
+    });
+    return sourceDir;
+}
+/**
+ * Fetches a validated remote skill directory snapshot for a specific repository path.
+ */
+export async function fetchRemoteSkillSnapshot(input) {
+    const normalizedRepo = normalizeRemoteRepo(input.repo);
+    const checkout = await cloneRemoteRepo({
+        ref: input.ref,
+        repo: normalizedRepo,
+    });
+    try {
+        const sourceDir = resolveRemoteSkillDirectory({
+            checkoutDir: checkout.checkoutDir,
+            skillPath: input.skillPath,
+        });
+        await validateRemoteSkillDirectory({
+            sourceDir,
+            skillPath: input.skillPath,
+            repo: normalizedRepo,
+        });
+        return {
+            cleanup: checkout.cleanup,
+            commit: checkout.commit,
+            sourceDir,
+        };
+    }
+    catch (error) {
+        await checkout.cleanup();
+        throw toError({
+            prefix: `Failed to fetch skill from ${normalizedRepo}`,
+            error,
+        });
+    }
+}
+export async function replaceManagedSkillDirectory({ targetDir, sourceDir, }) {
+    await fs.ensureDir(path.dirname(targetDir));
+    const stagingRoot = await fs.mkdtemp(path.join(path.dirname(targetDir), `${path.basename(targetDir)}.`));
+    const stagedDir = path.join(stagingRoot, path.basename(targetDir));
+    try {
+        await fs.copy(sourceDir, stagedDir);
+        await fs.remove(targetDir);
+        await fs.move(stagedDir, targetDir, { overwrite: true });
+    }
+    finally {
+        await fs.remove(stagingRoot);
+    }
+}
+export async function removeManagedSkillDirectory(context, { skillName }) {
+    await fs.remove(getManagedSkillDirectory(context, { skillName }));
+}
+export function formatManagedSkillSummary(skill) {
+    const refLabel = skill.ref ? skill.ref : 'HEAD';
+    return `${skill.name} repo=${skill.repo} path=${skill.path} ref=${refLabel} commit=${shortCommit(skill.commit)}`;
+}
+export function shortCommit(commit) {
+    return commit.slice(0, 7);
+}
+export function timestampNow() {
+    return new Date().toISOString();
+}
+function sortSkillsLockfile(lockfile) {
+    return {
+        version: lockfile.version,
+        skills: [...lockfile.skills].sort((left, right) => left.name.localeCompare(right.name)),
+    };
+}
+/**
+ * Derives the default managed skill name when the caller does not provide `--as`.
+ *
+ * When `skillPath` points to a subdirectory, the last path segment is used.
+ * When `skillPath` is `.`, the repository name is used instead.
+ *
+ * @example
+ * Input: { repo: 'anthropics/skills', skillPath: 'skills/skill-creator' }
+ * Output: 'skill-creator'
+ *
+ * @example
+ * Input: { repo: 'https://github.com/anthropics/skills.git', skillPath: '.' }
+ * Output: 'skills'
+ */
+function inferDefaultSkillName({ repo, skillPath, }) {
+    if (skillPath !== '.') {
+        return path.basename(skillPath);
+    }
+    const trimmedRepo = repo.replace(/\/+$/u, '');
+    const repoSegments = trimmedRepo.split(/[/:]/u).filter((segment) => segment);
+    const lastSegment = repoSegments[repoSegments.length - 1] ?? trimmedRepo;
+    return lastSegment.endsWith('.git') ? lastSegment.slice(0, -4) : lastSegment;
+}
+const githubRepoShorthandPattern = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:\.git)?$/u;
+function resolveRemoteSkillDirectory({ checkoutDir, skillPath, }) {
+    const candidateDir = path.resolve(checkoutDir, skillPath);
+    const relativeCandidatePath = path.relative(checkoutDir, candidateDir);
+    if (relativeCandidatePath === '..' ||
+        relativeCandidatePath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativeCandidatePath)) {
+        throw new Error(`Skill path escapes the repository checkout: ${skillPath}`);
+    }
+    return candidateDir;
+}
+async function validateRemoteSkillDirectory({ sourceDir, skillPath, repo, }) {
+    if (!(await fs.pathExists(sourceDir))) {
+        throw new Error(`Skill path does not exist in ${repo}: ${skillPath}`);
+    }
+    const stats = await fs.stat(sourceDir);
+    if (!stats.isDirectory()) {
+        throw new Error(`Skill path is not a directory in ${repo}: ${skillPath}`);
+    }
+    const skillMarkdownPath = path.join(sourceDir, 'SKILL.md');
+    if (!(await fs.pathExists(skillMarkdownPath))) {
+        throw new Error(`Missing SKILL.md in imported skill directory: ${skillPath}`);
+    }
+}
+function toError({ prefix, error }) {
+    if (error instanceof Error) {
+        return new Error(`${prefix}: ${error.message}`);
+    }
+    return new Error(`${prefix}: ${String(error)}`);
+}

package/dest/main.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dest/main.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+import { runInstallCommand } from './commands/install.js';
+import { addSkillsCommand } from './commands/skills/index.js';
+import { nonEmptyOptionStringSchema, parseOptionValue, parseOptionsObject, } from './lib/command-options.js';
+import { createAgentsContext, resolveRequestedOutputRoot, } from './lib/context.js';
+const rootOptionsSchema = z.object({
+    test: z.boolean().optional().default(false),
+    input: nonEmptyOptionStringSchema.optional(),
+    output: nonEmptyOptionStringSchema.optional(),
+});
+/**
+ * Reads the CLI version from the package manifest at the repository root.
+ */
+async function readCliVersion() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const packageJsonPath = path.resolve(currentFilePath, '..', '..', 'package.json');
+    const rawPackageJson = await fs.readFile(packageJsonPath, 'utf8');
+    const parsedPackageJson = JSON.parse(rawPackageJson);
+    const packageJsonSchema = z.object({
+        version: z.string().min(1),
+    });
+    return packageJsonSchema.parse(parsedPackageJson).version;
+}
+/**
+ * Parses the top-level CLI options into a validated shape.
+ */
+function getRootOptions(program) {
+    return parseOptionsObject({
+        schema: rootOptionsSchema,
+        options: program.opts(),
+        optionsLabel: 'root options',
+    });
+}
+/**
+ * Returns the active context after applying root-level input and output
+ * overrides.
+ */
+function resolveActiveContext(program) {
+    const rootOptions = getRootOptions(program);
+    const requestedOutputRoot = resolveRequestedOutputRoot({
+        test: rootOptions.test,
+        ...(rootOptions.output ? { outputRoot: rootOptions.output } : {}),
+    });
+    const context = createAgentsContext({
+        ...(rootOptions.input ? { inputRoot: rootOptions.input } : {}),
+        ...(requestedOutputRoot ? { outputRoot: requestedOutputRoot } : {}),
+    });
+    return context;
+}
+/**
+ * Configures and runs the agents CLI entrypoint.
+ */
+async function main() {
+    const executableName = 'dryai';
+    const program = new Command();
+    const cliVersion = await readCliVersion();
+    program
+        .name(executableName)
+        .usage('[options] <command> [args]')
+        .helpOption('-h, --help', 'Display this message')
+        .version(cliVersion, '-v, --version', 'Display the current version')
+        .option('--test', 'Shortcut for writing generated output into ./output-test unless --output is also provided')
+        .option('--input <path>', 'Read input configs from a different root instead of ~/.config/agents', parseOptionValue({
+        schema: nonEmptyOptionStringSchema,
+        optionLabel: '--input',
+    }))
+        .option('--output <path>', 'Write generated output under a different root instead of the default home directory', parseOptionValue({
+        schema: nonEmptyOptionStringSchema,
+        optionLabel: '--output',
+    }))
+        .helpCommand(false)
+        .action(() => {
+        program.outputHelp();
+    });
+    program
+        .command('install')
+        .description('Install generated output into Copilot and Cursor targets')
+        .usage('install')
+        .action(async () => {
+        const activeContext = resolveActiveContext(program);
+        await runInstallCommand(activeContext);
+        if (requestedOutputRootWasUsed(program)) {
+            console.log(`Generated output written to ${activeContext.outputRoot}`);
+        }
+    });
+    addSkillsCommand({
+        parent: program,
+        commandName: `${executableName} skills`,
+        resolveContext: () => resolveActiveContext(program),
+    });
+    await program.parseAsync(process.argv);
+}
+/**
+ * Returns whether the current invocation requested a non-default output root.
+ */
+function requestedOutputRootWasUsed(program) {
+    const rootOptions = getRootOptions(program);
+    return (resolveRequestedOutputRoot({
+        test: rootOptions.test,
+        ...(rootOptions.output ? { outputRoot: rootOptions.output } : {}),
+    }) !== undefined);
+}
+try {
+    await main();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(message);
+    process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "dryai",
+  "version": "0.2.1",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dest/**/*.js",
+    "dest/**/*.d.ts"
+  ],
+  "scripts": {
+    "setup:editor": "effect-language-service patch",
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "dev:dryai": "node ./dest/main.js",
+    "tsc": "tsc -b",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "bin": {
+    "dryai": "dest/main.js"
+  },
+  "dependencies": {
+    "@effect/cli": "^0.75.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "dedent": "^1.7.2",
+    "effect": "^3.21.0",
+    "fs-extra": "^11.3.4",
+    "glob": "^13.0.6",
+    "gray-matter": "^4.0.3",
+    "simple-git": "^3.35.2",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@effect/language-service": "^0.85.0",
+    "@effect/vitest": "^0.29.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^24.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.4"
+  },
+  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319"
+}